killdream/athena

2013-05-22 04:56:10
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
22.0
✓23.0
25.0
24.0
26.0
27.0
28.0
29.0
15.0
16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
11.0
✓11.6
✓12.0
11.5
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 15% - false true true o 15% - true true false o 15% - true false true o 39% - true true true o 5% - true false false o 6% - false true false o 2% - false false false o 4% - false false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 2% - false false false o 13% - true true false o 16% - true false true o 12% - false true true o 41% - true true true o 6% - false true false o 5% - false false true o 5% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 26% - false o 74% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 40% - true true true o 4% - false true false o 4% - true false false o 2% - false false false o 15% - true false true o 15% - false true true o 14% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - false false true o 5% - true false false o 38% - true true true o 2% - false false false o 16% - true true false o 13% - true false true o 15% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 TAP version 13 ok 1 {} core noop() Should do nothing ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 39% - true true true o 2% - false false false o 14% - true true false o 14% - false true true o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 42% - true true true o 2% - false false false o 14% - true false true o 13% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3 + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 13% - true false true o 14% - true true false o 14% - false true true o 7% - false false true o 2% - false false false o 4% - false true false o 6% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 25% - false o 75% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds.
timeout waiting to hear back from firefox/16.0
TAP version 13 TAP version 13 TAP version 13 ok 1 {} core noop() Should do nothing ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 41% - true true true o 2% - false false false o 15% - true true false o 14% - true false true o 13% - false true true ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 40% - true true true o 2% - false false false o 15% - true true false o 14% - false true true o 13% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3 ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 39% - true true true o 15% - true true false o 14% - true false true o 14% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 66% - true o 34% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 1 {} core noop() Should do nothing ok 3 {} core k() When applied to another argument, should return the first. ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 36% - true true true o 2% - false false false o 16% - true true false o 15% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false true false o 5% - false false true o 40% - true true true o 4% - true false false o 2% - false false false o 17% - false true true o 15% - true false true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 65% - true o 35% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false true false o 42% - true true true o 4% - true false false o 3% - false false true o 3% - false false false o 15% - false true true o 14% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 66% - true o 34% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument.
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 13% - false true true o 3% - false false false o 14% - true false true o 13% - true true false o 6% - false false true o 5% - false true false o 6% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 26% - false o 74% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 533
not ok 1 Error: Object expected on line 534
not ok 1 Error: Object expected on line 534
2013-05-21 02:20:17
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
✓16.0
✓17.0
✓18.0
✓19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 14% - true true false o 39% - true true true o 16% - false true true o 6% - false true false o 13% - true false true o 5% - false false true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 25% - false o 75% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 14% - true true false o 16% - true false true o 14% - false true true o 6% - false true false o 38% - true true true o 2% - false false false o 5% - false false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 30% - false o 70% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 4% - false false true o 39% - true true true o 2% - false false false o 16% - true true false o 14% - false true true o 15% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 39% - true true true o 13% - false true true o 13% - true false true o 1% - false false false o 18% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
timeout waiting to hear back from opera/11.5
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - false true false o 37% - true true true o 2% - false false false o 4% - true false false o 16% - true false true o 15% - true true false o 15% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - true false true o 6% - false true false o 15% - true true false o 36% - true true true o 5% - true false false o 16% - false true true o 6% - false false true o 3% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 26% - false o 74% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 33% - false o 67% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 39% - true true true o 3% - false false false o 15% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 40% - true true true o 3% - true false false o 2% - false false false o 15% - false true true o 14% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 4% - false true false o 39% - true true true o 16% - false true true o 15% - true true false o 14% - true false true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - true false false o 5% - false false true o 44% - true true true o 4% - false true false o 14% - true false true o 13% - true true false o 12% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 41% - true true true o 4% - true false false o 4% - false true false o 2% - false false false o 15% - true true false o 14% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false not ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) --- type: Error message: > Timeout of 2000 exceeded. stack: | timeout@http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2286 _run@http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:1645 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2117 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2108 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2100 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2096 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:2165 @http://git.testling.com/work/killdream/repos/ac8a47b01e2b688e84bc15606595a4b033ec4816.1369098548578/1369098549162.4b68730c.js:429 ... + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 40% - true true true o 15% - false true true o 14% - true true false o 13% - true false true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 80% - true o 20% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 39% - true true true o 2% - false false false o 15% - true true false o 14% - false true true o 13% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 5% - false false true o 41% - true true true o 15% - true true false o 15% - true false true o 13% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 40% - true true true o 2% - false false false o 15% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 5% - false false true o 37% - true true true o 2% - false false false o 16% - true true false o 15% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 5% - false false true o 39% - true true true o 2% - false false false o 15% - true false true o 14% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 82% - true o 18% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 38% - true true true o 5% - true false false o 16% - true false true o 16% - true true false o 14% - false true true o 4% - false false true o 5% - false true false o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 29% - false o 71% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 28% - false o 72% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 14% - false true true o 14% - true false true o 14% - true true false o 3% - false false false o 6% - true false false o 5% - false false true o 4% - false true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 705
not ok 1 Error: Object expected on line 706
not ok 1 Error: Object expected on line 706
2013-05-20 00:26:41
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
✓16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
11.0
11.5
✓11.6
12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - false true true o 39% - true true true o 13% - true true false o 16% - true false true o 5% - false false true o 5% - false true false o 6% - true false false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false false true o 14% - false true true o 15% - true true false o 5% - true false false o 40% - true true true o 13% - true false true o 2% - false false false o 6% - false true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 23% - false o 77% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 42% - true true true o 4% - false true false o 4% - false false true o 2% - false false false o 15% - true true false o 14% - false true true o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 13% - true false true o 39% - true true true o 14% - false true true o 14% - true true false o 3% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 69% - true o 31% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 41% - true true true o 2% - false false false o 14% - true true false o 14% - false true true o 15% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 42% - true true true o 13% - true false true o 14% - false true true o 14% - true true false o 5% - false false true o 1% - false false false o 6% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 26% - false o 74% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false true false o 5% - false false true o 35% - true true true o 2% - false false false o 16% - true true false o 16% - false true true o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 40% - true true true o 2% - false false false o 14% - true true false o 14% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false not ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) --- type: Error message: > Timeout of 2000 exceeded. stack: | timeout@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2292 _run@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:1456 [23]</</attemptApplication@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2123 [23]</</applyPromise@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2114 [23]</</toFulfilled@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2106 [23]</</makeBindings/<@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2102 [23]</</pinkyPromise/transition/</<@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:2171 [17]</<@http://git.testling.com/work/killdream/repos/a23c8caf2e885c1b651d314d2aab43fc2938c768.1369005202001/1369005202337.9a384592.js:578 ... + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 5% - false false true o 40% - true true true o 2% - false false false o 15% - false true true o 14% - true false true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 79% - true o 21% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 42% - true true true o 4% - false true false o 4% - false false true o 15% - false true true o 14% - true true false o 14% - true false true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 80% - true o 20% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - false true false o 4% - true false false o 38% - true true true o 2% - false false false o 16% - true true false o 15% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 42% - true true true o 2% - false false false o 14% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 64% - true o 36% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 40% - true true true o 2% - false false false o 15% - false true true o 14% - true false true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 69% - true o 31% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false true false o 5% - true false false o 4% - false false true o 39% - true true true o 2% - false false false o 16% - true true false o 14% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 41% - true true true o 2% - false false false o 15% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 79% - true o 21% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 38% - true true true o 3% - false true false o 2% - false false false o 17% - false true true o 15% - true true false o 13% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 70% - true o 31% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 38% - true true true o 2% - false false false o 15% - true true false o 15% - false true true o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 76% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 5% - false false true o 5% - true false false o 16% - true true false o 14% - false true true o 14% - true false true o 5% - false true false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 69% - true o 31% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 16% - true true false o 16% - false true true o 13% - true false true o 5% - false true false o 5% - true false false o 2% - false false false o 4% - false false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 70% - true o 30% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 80% - true o 20% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 533
not ok 1 Error: Object expected on line 534
not ok 1 Error: Object expected on line 534
2013-05-20 00:09:42
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 16% - false true true o 16% - true false true o 38% - true true true o 6% - false true false o 14% - true true false o 5% - false false true o 1% - false false false o 5% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 13% - true true false o 13% - true false true o 7% - true false false o 5% - false false true o 14% - false true true o 3% - false false false o 6% - false true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 77% - true o 23% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 79% - true o 21% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false false true o 5% - true false false o 5% - false true false o 39% - true true true o 2% - false false false o 15% - true true false o 14% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 4% - true false false o 4% - false false true o 38% - true true true o 2% - false false false o 17% - true false true o 14% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 37% - true true true o 2% - false false false o 5% - false false true o 17% - true true false o 15% - false true true o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 70% - true o 31% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 17% - true false true o 13% - false true true o 15% - true true false o 5% - false false true o 1% - false false false o 5% - true false false o 5% - false true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 19% - false o 81% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 40% - true true true o 2% - false false false o 15% - false true true o 14% - true false true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false true false o 7% - false false true o 5% - true false false o 39% - true true true o 2% - false false false o 15% - true false true o 13% - true true false o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 70% - true o 30% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false false true o 6% - true false false o 6% - false true false o 36% - true true true o 2% - false false false o 15% - false true true o 14% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false false true o 5% - false true false o 40% - true true true o 4% - true false false o 2% - false false false o 16% - true true false o 14% - false true true o 12% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 76% - true o 24% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 41% - true true true o 2% - false false false o 15% - true true false o 15% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false true false o 5% - false false true o 41% - true true true o 4% - true false false o 2% - false false false o 15% - true true false o 15% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 38% - true true true o 2% - false false false o 15% - true true false o 15% - false true true o 12% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 43% - true true true o 4% - false false true o 15% - true false true o 14% - false true true o 13% - true true false o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - true false false o 5% - false true false o 5% - false false true o 40% - true true true o 2% - false false false o 16% - false true true o 13% - true true false o 13% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 39% - true true true o 2% - false false false o 16% - false true true o 14% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 40% - true true true o 2% - false false false o 14% - true true false o 14% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false false true o 40% - true true true o 14% - true false true o 6% - false true false o 14% - true true false o 15% - false true true o 2% - false false false o 4% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - true true false o 38% - true true true o 14% - true false true o 6% - false false true o 5% - false true false o 7% - true false false o 16% - false true true o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 77% - true o 23% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 705
not ok 1 Error: Object expected on line 706
not ok 1 Error: Object expected on line 706
2013-05-19 22:17:04
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
11.0
11.5
✓11.6
✓12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 42% - true true true o 13% - true false true o 13% - true true false o 15% - false true true o 4% - false true false o 6% - false false true o 5% - true false false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - true false true o 16% - true true false o 38% - true true true o 6% - false false true o 6% - false true false o 14% - false true true o 4% - true false false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 26% - false o 74% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false true false o 5% - true false false o 5% - false false true o 39% - true true true o 2% - false false false o 16% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 2% - false false false o 38% - true true true o 15% - true false true o 14% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 38% - true true true o 1% - false false false o 17% - true true false o 14% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 39% - true true true o 15% - true true false o 14% - false true true o 17% - true false true o 5% - true false false o 4% - false true false o 3% - false false false o 4% - false false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 27% - false o 73% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 4% - false false true o 38% - true true true o 17% - true false true o 15% - false true true o 14% - true true false o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 64% - true o 36% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false false true o 5% - true false false o 5% - false true false o 39% - true true true o 3% - false false false o 14% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 40% - true true true o 2% - false false false o 14% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false not ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) --- type: Error message: > Timeout of 2000 exceeded. stack: | timeout@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2292 _run@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:1651 attemptApplication@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2123 applyPromise@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2114 toFulfilled@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2106 makeBindings/<@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2102 pinkyPromise/transition/</<@http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:2171 @http://git.testling.com/work/killdream/repos/826fef5b5b55e1bf269b3ec40f95d0b5b5654928.1368997457468/1368997458259.226275df.js:578 ... + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 39% - true true true o 2% - false false false o 16% - false true true o 15% - true false true o 12% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 85% - true o 15% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false true false o 5% - false false true o 42% - true true true o 2% - false false false o 13% - true true false o 13% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 39% - true true true o 16% - true true false o 15% - true false true o 14% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 69% - true o 31% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 40% - true true true o 2% - false false false o 14% - true true false o 13% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 40% - true true true o 3% - false false false o 15% - true true false o 14% - false true true o 12% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 70% - true o 30% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - false false true o 4% - true false false o 39% - true true true o 2% - false false false o 16% - false true true o 15% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 5% - false true false o 40% - true true true o 2% - false false false o 15% - false true true o 14% - true true false o 14% - true false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 36% - true true true o 3% - false false false o 15% - true true false o 15% - true false true o 15% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 77% - true o 23% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 40% - true true true o 15% - false true true o 15% - true true false o 5% - false true false o 13% - true false true o 2% - false false false o 6% - false false true o 5% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 25% - false o 75% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - false true true o 13% - true true false o 42% - true true true o 4% - false false true o 15% - true false true o 5% - false true false o 4% - true false false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 533
not ok 1 Error: Object expected on line 534
not ok 1 Error: Object expected on line 534
2013-05-19 21:21:47
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
11.6
12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 14% - true true false o 41% - true true true o 15% - true false true o 13% - false true true o 6% - false false true o 5% - false true false o 6% - true false false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 27% - false o 73% - true ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 84% - true o 16% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 13% - true true false o 2% - false false false o 40% - true true true o 5% - true false false o 5% - false true false o 16% - false true true o 16% - true false true o 5% - false false true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - true false false o 39% - true true true o 1% - false false false o 5% - false true false o 16% - true true false o 14% - true false true o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 4% - false false true o 40% - true true true o 2% - false false false o 15% - true true false o 15% - true false true o 15% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false false true o 5% - false true false o 41% - true true true o 4% - true false false o 2% - false false false o 15% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 73% - true o 27% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 41% - true true true o 14% - true false true o 5% - false true false o 14% - true true false o 4% - true false false o 6% - false false true o 15% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 24% - false o 76% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 6% - false false true o 5% - true false false o 37% - true true true o 2% - false false false o 15% - true false true o 15% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 5% - false true false o 5% - false false true o 39% - true true true o 3% - false false false o 15% - true false true o 15% - false true true o 14% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 76% - true o 24% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 4% - false false true o 39% - true true true o 3% - false false false o 16% - true true false o 14% - true false true o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false true false o 5% - true false false o 5% - false false true o 39% - true true true o 17% - true true false o 14% - true false true o 12% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 78% - true o 22% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 5% - false false true o 38% - true true true o 3% - false false false o 16% - true false true o 15% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 69% - true o 31% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 26 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false false true o 5% - false true false o 39% - true true true o 2% - false false false o 15% - true false true o 14% - true true false o 14% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 72% - true o 28% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - true false false o 5% - false true false o 5% - false false true o 39% - true true true o 2% - false false false o 16% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 75% - true o 25% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - false true false o 5% - true false false o 5% - false false true o 43% - true true true o 2% - false false false o 14% - true false true o 14% - false true true o 12% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 75% - true o 25% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 6% - true false false o 6% - false true false o 41% - true true true o 4% - false false true o 15% - true true false o 14% - true false true o 14% - false true true o 1% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 71% - true o 29% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 72% - true o 28% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 7% - false false true o 6% - true false false o 4% - false true false o 39% - true true true o 2% - false false false o 16% - true false true o 13% - true true false o 13% - false true true ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 74% - true o 26% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 67% - true o 33% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - true false false o 5% - false true false o 43% - true true true o 4% - false false true o 2% - false false false o 15% - true false true o 14% - false true true o 13% - true true false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 74% - true o 26% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 39% - true true true o 15% - false true true o 5% - false false true o 5% - true false false o 13% - true true false o 16% - true false true o 5% - false true false o 2% - false false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 73% - true o 27% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 71% - true o 29% - false ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. + OK passed 1000 tests. > Collected test data: o 5% - false true false o 15% - false true true o 14% - true true false o 41% - true true true o 2% - false false false o 15% - true false true o 4% - false false true o 5% - true false false ok 25 {} logic or() or(f, g, h)(a) = f(a) || g(a) || h(a) + OK passed 1000 tests. > Collected test data: o 77% - true o 24% - false ok 26 {} logic and() and(f, g, h)(a) = f(a) && g(a) && h(a) + OK passed 100 tests. > Collected test data: o 26% - false o 74% - true ok 27 {} logic not() not(f)(a) = !f(a) 1..27 # tests 27 # pass 27 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 705
not ok 1 Error: Object expected on line 706
not ok 1 Error: Object expected on line 706
2013-05-19 20:41:41
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
16.0
17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 23 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. ok 19 {} flow either() either(p, f, g)(a) = if p(a) then f(a) else g(a). ok 20 {} flow unless() unless(p, f)(a) = if not p(a) then f(a). ok 21 {} flow limit() Should return the value if invocations < limit. ok 22 {} flow once() Should return the value only in the first invocation. ok 23 {} flow until() Should only yield values before the predicate holds. ok 24 {} flow when() Should only yield values after the predicate holds. 1..24 # tests 24 # pass 24 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 657
not ok 1 Error: Object expected on line 658
not ok 1 Error: Object expected on line 658
2013-05-19 19:44:02
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
15.0
16.0
✓17.0
18.0
19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
12.0
15.0
6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3 ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 17 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 17 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 17 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. not ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 17 # fail 1 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. ok 17 {} async delay() Should execute the function after the given seconds. ok 18 {} async defer() Should execute in the next loop/end of this loop. 1..18 # tests 18 # pass 18 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 593
not ok 1 Error: Object expected on line 594
not ok 1 Error: Object expected on line 594
2013-05-19 18:46:18
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
✓15.0
✓16.0
✓17.0
✓18.0
✓19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 485
not ok 1 Error: Object expected on line 486
not ok 1 Error: Object expected on line 486
2013-05-19 17:12:26
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
✓15.0
✓16.0
✓17.0
✓18.0
✓19.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X ok 5 {} higher-order compose() Given `f: a → b` and `g: b → c`, then `(g . f): a → c` ok 6 {} higher-order compose() associativity: `f . (g . h)` = `(f . g) . h` ok 7 {} higher-order compose() left identity: `id . f` = f` ok 8 {} higher-order compose() right identity: `f . id` = f` ok 9 {} higher-order curry() Given `f: (a, b) → c`, a curried form should be `f: a → b → c` ok 10 {} higher-order curry() Should allow specifying arity for variadic functions. ok 11 {} higher-order curry() Should allow more than one argument applied at a time. ok 12 {} higher-order curry() Should accept initial arguments as an array. ok 13 {} higher-order partial() For a function `f: (a..., b...) → c`, should yield `f: (b...) → c` ok 14 {} higher-order uncurry() Should convert an `f: (a... -> b)` into `f: [a] -> b` ok 15 {} higher-order uncurry-bind() Should convert an `f: (a... -> b)` into `f: [this, a...] -> b` # ignored: {} higher-order flip() Should return a function of the same length. # ignored: {} higher-order flip() flip(f)(b)(a) = f(a, b). # ignored: {} higher-order flip() flip(flip(f)(b))(a) = flip(a, b). ok 16 {} higher-order wrap() Should pass the wrapped function as first argument. 1..16 # tests 16 # pass 16 # fail 0 # ignored 3
not ok 1 Error: Object expected on line 485
not ok 1 Error: Object expected on line 486
not ok 1 Error: Object expected on line 486
2013-05-19 15:28:14
6.0
7.0
8.0
✓9.0
✓10.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓25.0
26.0
27.0
28.0
29.0
✓15.0
✓16.0
✓18.0
✓19.0
17.0
20.0
21.0
22.0
23.0
24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
15.0
✓6.0
✓6.0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
idle timeout: 30 seconds with no output
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
TAP version 13 ok 1 {} core noop() Should do nothing ok 2 {} core k() When applied to X should return a function ok 3 {} core k() When applied to another argument, should return the first. ok 4 {} core id() When applied to X, should return X 1..4 # tests 4 # pass 4 # fail 0 # ignored 0
not ok 1 Error: Object expected on line 411
not ok 1 Error: Object expected on line 412
not ok 1 Error: Object expected on line 412