DEV Community: Derek Enos

Predilection for Predicates

Derek Enos — Wed, 08 Sep 2021 13:34:48 +0000

I recently wanted to query arrays of Javascript objects using a declarative syntax and happily took the opportunity to write some small functions.

Predicates

EQ (is equal to)

const EQ = x => y => x === y

For anyone unfamiliar with ES6 arrow functions:

EQ is a function that accepts one argument (x) that returns another function that accepts one argument (y) which returns the result of evaluating x === y.

Here's the equivalent standard function def:

function EQ (x) {
  return function (y) {
    return x === y
  }
}

IN (is included in)

const IN = (...xs) => x => xs.includes(x)

IN is a function that accepts one or more arguments collected into an array (xs) that returns another function that accepts one argument (x) which returns the result of evaluating xs.includes(x).

Logical Operators

const NOT = pred => x => !pred(x)

const AND = (...preds) => x => preds.reduce((acc, pred) => acc && pred(x), true)

const OR = (...preds) => x => preds.reduce((acc, pred) => acc || pred(x), false)

Doing Stuff

Filtering Scalar Arrays

const data = [ 1, 2, 1, 1, 3, 2, 2, 2 ]

Get All the `1`s

>> data.filter(EQ(1))
Array(3) [ 1, 1, 1 ]

Get All the `1`s and `2`s

>> data.filter(IN(1, 2))
Array(7) [ 1, 2, 1, 1, 2, 2, 2 ]

>> data.filter(OR(EQ(1), EQ(2)))
Array(7) [ 1, 2, 1, 1, 2, 2, 2 ]

Filtering Arrays of Objects

The above EQ and IN predicate functions work great with scalar values (i.e. numbers, booleans, etc), but I needed something that works on objects:

const OBJ = spec => obj => Object.entries(spec).reduce((acc, [k, pred]) => acc && pred(obj[k]), true)

OBJ accepts an object-type spec argument that maps key names to predicates.
For example, a spec value of:

{ isAdmin: EQ(true), active: EQ(true) }

would match objects with isAdmin = true AND active = true. For performing logical ops other than AND, you can specify them separately and wrap them appropriately. For example, to do an OR query on these same property values:

OR( OBJ({ isAdmin: EQ(true) }), OBJ({ active: EQ(true) }) )

Better may be to create an OBJ_OR or something but...moving on

Get some legit-looking data from JSONPlaceholder

const Todos = await (await fetch("https://jsonplaceholder.typicode.com/todos")).json()

The returned array looks like:

[
  {
    "userId": 1,
    "id": 1,
    "title": "delectus aut autem",
    "completed": false
  },
  ...
]

Find all uncompleted Todos from Users `1` and `2`:

>> Todos.filter(OBJ({userId: IN(1, 2), completed: EQ(false)}))
Array(21) [ {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, … ]

🎉

Optimizations omitted in favor of simplicity

Short-circuit AND and OR on first false or true respectively instead of iterating over the entire array of object entries.
Support implicit EQ for non-predicate-function object spec values, e.g. { isAdmin: true } would be interpreted as { isAdmin: EQ(true) }.

No <head>, no <body>, no problem?

Derek Enos — Mon, 01 Mar 2021 16:02:12 +0000

I was surprised today when I discovered that the HTML response from https://twitter.com does not include a <head> tag (or <body> for that matter), though does include tags (e.g. <meta charset>) that are only valid as children of <head>.

Today I learned that this is ok.

Per the HTML spec:

A head element's start tag can be omitted if the element is empty, or if the first thing inside the head element is an element.

A head element's end tag can be omitted if the head element is not immediately followed by ASCII whitespace or a comment.

Similar applies to <html> and <body>, see: https://html.spec.whatwg.org/multipage/syntax.html#syntax-tag-omission

This Google HTML/CSS Style Guide even recommends omitting all optional tags.

Python Charming with Toolz

Derek Enos — Sat, 18 May 2019 19:53:27 +0000

Toolz is an extremely useful collection of utility functions that can help you do things that you do all the time, but more explicitly, and often with less code.

I'm going to highlight a few of the functions that I use the most, but there are many others, and they're all solid gold.

Create a new `dict` from an existing `dict` with some items excluded

Given an original dict:

original = {
    'A': 1,
    'B': 2,
    'C': 3,
}

Filtering items by key

To create a new dict from original while excluding the item with key='C', without toolz, I'd probably do:

new = {
    k: v
    for k, v in original.items()
    if k != 'C'
}

Using dicttoolz.keyfilter, this becomes:

new = keyfilter(lambda k: k != 'C', original)

What I really love about this keyfilter solution, aside from being more concise, functional, etc., is that its name clearly tells you what's going on.

Filtering items by value

Given a helper function called is_even that returns a bool indicating whether the single numeric argument is even:

is_even = lambda x: x % 2 == 0

Or, as not a lambda:

def is_even(x):
    return x % 2 == 0

To create a new dict from original while including only the even values, without toolz, I'd probably do:

new = {
    k: v
    for k, v in original.items()
    if is_even(v)
}

Using dicttoolz.valfilter, this becomes:

new = valfilter(is_even, original)

For a single key, get the value from each `dict` in a `list` of `dict`s

Given a list of dicts representing users:

users = [
    { 'name': 'User A',
      'age': 30,
    }, 
    { 'name': 'User B',
      'age': 32,
    }, 
    { 'name': 'User C',
      'age': 41,
    }, 
    { 'name': 'User D',
      'age': 43,
    }, 
]

To get just the ages, without toolz, I'd do:

ages = [ user['age'] for user in users ]

Using itertoolz.pluck, this becomes:

ages = pluck('age', users)

Note that this ^ (like some other toolz functions) actually returns a generator-type itertools.imap object, which is fine if you're going to iterate over it, but if you want to index into it like ages[0], you'll need to convert it to a list (or tuple):

>>> ages[0]
TypeError: 'itertools.imap' object has no attribute '__getitem__'

>>> ages = list(pluck('age', users))
>>> ages[0]
30

You can also pluck multiple keys at once by specifying them as a list:

age_name_pairs = pluck(['age', 'name'], users)

Which looks like:

>>> list(age_name_pairs)
[(30, 'User A'), (32, 'User B'), (41, 'User C'), (43, 'User D')]

Group a `list` of `dict`s by some criteria

Given the same list of user dicts as before:

users = [
    { 'name': 'User A',
      'age': 30,
    }, 
    { 'name': 'User B',
      'age': 32,
    }, 
    { 'name': 'User C',
      'age': 41,
    }, 
    { 'name': 'User D',
      'age': 43,
    }, 
]

If I wanted to group the users into decade-resolution age groups (i.e. 30s, 40s, etc.), without toolz maybe I'd do something like:

age_decade_users_map = defaultdict(list)
for user in users:
    age_decade = int(user['age'] / 10) * 10
    age_decade_users_map[age_decade].append(user)

This produces:

>>> dict(age_decade_users_map)
{30: [{'age': 30, 'name': 'User A'}, {'age': 32, 'name': 'User B'}],
 40: [{'age': 41, 'name': 'User C'}, {'age': 43, 'name': 'User D'}]}

Using itertoolz.groupby, this can be accomplished with:

age_decade_users_map = groupby(
    lambda user: int(user['age'] / 10) * 10,
    users
)

Honorable mention goes to:

itertoolz.first - get the first element from an iterable (even sets!)
itertoolz.partitional_all - split an iterable into tuples of a specified max length
dicttoolz.assoc - get a copy of a dict with a specified item added
dicttoolz.dissoc - get a copy of a dict with specified keys removed (similar in function to my keyfilter example but a better way to do it)
dicttoolz.get_in - like dict.get() but with support for multi-depth keys, e.g. get_in(['a', 'b'], {'a': {'b': 1}}) = 1

Happy toolzing!