☰
composition
composition
Functions
S
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
hook, monadic after
Bird: Starling
BQN: ⟜
Haskell: <*>
D
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
composition of one binary function f and one unary function g...
Bird: Dove
BQN: ⟜
Haskell:
create a String from this instance. Unless redefined, `a.as_string` will
create `"instance[T]"` where `T` is the dynamic type of `a`
create `"instance[T]"` where `T` is the dynamic type of `a`
B1
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
Elementary Compositor, 1° <- 2° composition
Bird: Blackbird
BQN: ∘
Haskell: .: or ...
B3
triple compositor
Bird: Becard
BQN:
Haskell:
triple compositor
Bird: Becard
BQN:
Haskell:
B
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
composition of one unary function f and one binary function g...
Bird: Bluebird
BQN: ⊸
B
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
Elementary Compositor, composition
Bird: Bluebird
BQN: ∘
Haskell: .
?
Constant cancellator?
Bird: ?
BQN: ˙
Constant cancellator?
Bird: ?
BQN: ˙
§(T type, U type, V type, v composition.const2.T):Any => Function composition.const2.T composition.const2.U composition.const2.V
§(T
type
, U type
, V type
, v composition.const2.T):
Any =>
Function composition.const2.T composition.const2.U composition.const2.V§(V type, T type, X type, W type, U type, f Unary composition.d2.V composition.d2.T, g Function composition.d2.X composition.d2.V composition.d2.W, h Unary composition.d2.W composition.d2.U):Any => Function composition.d2.X composition.d2.T composition.d2.U
§(V
type
, T type
, X type
, W type
, U type
, f Unary composition.d2.V composition.d2.T, g Function composition.d2.X composition.d2.V composition.d2.W, h Unary composition.d2.W composition.d2.U):
Any =>
Function composition.d2.X composition.d2.T composition.d2.UD2
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
composition of one binary function g and tow unary functions f, h
Bird: Dovekie
BQN: a⊸b⟜c
Uiua: ⊓ aka bracket
Haskell:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
C
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
Elementary Permutator, reverse arguments
Bird: Cardinal
BQN: ˜
Haskell: flip
§(V type, U1 type, U2 type, T1 type, T2 type, f Function composition.fork.V composition.fork.U1 composition.fork.U2, g Unary composition.fork.U1 composition.fork.T1, h Unary composition.fork.U2 composition.fork.T2):Any => Function composition.fork.V composition.fork.T1 composition.fork.T2
§(V
type
, U1 type
, U2 type
, T1 type
, T2 type
, f Function composition.fork.V composition.fork.U1 composition.fork.U2, g Unary composition.fork.U1 composition.fork.T1, h Unary composition.fork.U2 composition.fork.T2):
Any =>
Function composition.fork.V composition.fork.T1 composition.fork.T2Φ (S′)
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
composition of two unary functions and one binary function
Bird: ?
BQN: 3-train?
Haskell: liftA2
§(V type, U1 type, U2 type, T1 type, T2 type, f Function composition.fork2.V composition.fork2.U1 composition.fork2.U2, g Function composition.fork2.U1 composition.fork2.T1 composition.fork2.T2, h Function composition.fork2.U2 composition.fork2.T1 composition.fork2.T2):Any => Function composition.fork2.V composition.fork2.T1 composition.fork2.T2
§(V
type
, U1 type
, U2 type
, T1 type
, T2 type
, f Function composition.fork2.V composition.fork2.U1 composition.fork2.U2, g Function composition.fork2.U1 composition.fork2.T1 composition.fork2.T2, h Function composition.fork2.U2 composition.fork2.T1 composition.fork2.T2):
Any =>
Function composition.fork2.V composition.fork2.T1 composition.fork2.T2Φ1
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
composition of two unary functions and one binary function
Bird: Pheasant (Hoekstra)
BQN: 3-train?
Haskell: ?
I
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
identity
Bird: Idiot (Smullyan) or Ibis (Gabriel Lebec)
BQN: ⊣⊢
Haskell: id
W
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
Elementary Duplicator
Bird: Warbler
BQN: ~
Haskell: join
K
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
Elementary Cancellator, first
Bird: Kestrel
BQN: ⊣
Haskell const
M
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
self application
Bird: Mockingbird
BQN: ?
Haskell: (cannot define)
This is not representable in Fuzion, we would need arguments with generic arguments
here. Using pseudo-syntax ((T,U type) <type using T,U>) to denote a type that is
itself type parameteric...:
public M(f ((T,U type) T -> U)) ((V,W type) V->W) => f f
we can emulate this if we require the argument to be given twice:
applying M to id:
Ψ - psi
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
composition of binary and unary function
Bird: ?
BQN: ○
Uiua: ∩ aka both
Haskell: on
§(A type, B type, f Unary composition.owl.A (Unary composition.owl.B composition.owl.A), g Unary composition.owl.B composition.owl.A):Any => composition.owl.B
§(A
type
, B type
, f Unary composition.owl.A (Unary composition.owl.B composition.owl.A), g Unary composition.owl.B composition.owl.A):
Any =>
composition.owl.BO
Bird: Owl
BQN: ?
Haskell: ?
Bird: Owl
BQN: ?
Haskell: ?
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
KI
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
second
left ∘ flip
Bird: Kite
BQN: ⊢
Haskell: const id
§(T type, U type, V type, x composition.thrush.T, f Function composition.thrush.V composition.thrush.T composition.thrush.U):Any => Unary composition.thrush.V composition.thrush.U
§(T
type
, U type
, V type
, x composition.thrush.T, f Function composition.thrush.V composition.thrush.T composition.thrush.U):
Any =>
Unary composition.thrush.V composition.thrush.UT
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
hold an argument
Bird: thrush
BQN: ?
Haskell: flip id
§(T type, U type, V type, W type, x composition.vireo.T, y composition.vireo.U, f Function composition.vireo.W composition.vireo.T composition.vireo.U composition.vireo.V):Any => Unary composition.vireo.W composition.vireo.V
§(T
type
, U type
, V type
, W type
, x composition.vireo.T, y composition.vireo.U, f Function composition.vireo.W composition.vireo.T composition.vireo.U composition.vireo.V):
Any =>
Unary composition.vireo.W composition.vireo.VV
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip id
hold a pair of arguments
Bird: vireo
BQN: ?
Haskell: flip . flip id
Type Features
string representation of this type to be used for debugging.
result has the form "Type of '<name>'", but this might change in the future
result has the form "Type of '<name>'", but this might change in the future
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
endless hierarchy of types, so dynamic_type is redefined to just return
Type.type here.
Is this type assignable to a type parameter with constraint `T`?
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
The result of this is a compile-time constant that can be used to specialize
code for a particular type.
is_of_integer_type(n T : numeric) => T : integer
say (is_of_integer_type 1234) # true
say (is_of_integer_type 3.14) # false
it is most useful in conjunction preconditions or `if` statements as in
pair(a,b T) is
=>
or
val(n T) is
name of this type, including type parameters, e.g. 'option (list i32)'.
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
see https://mlochbaum.github.io/BQN/tutorial/combinator.html
Talk at Strange Loop 2016 by Amar Shah: Point-Free or Die: Tacit Programming in Haskell and Beyond
https://www.youtube.com/watch?v=seVSlKazsNk
Talk at CppNorth 2023 by Conor Hoekstra: Function Composition in Programming Languages - Conor Hoekstra - CppNorth 2023
https://www.youtube.com/watch?v=JELcdZLre3s
Paper by Conor Hoekstra: Combinatory Logic and Combinators in Array Languages
https://web.archive.org/web/20220617020347id_/https://dl.acm.org/doi/pdf/10.1145/3520306.3534504
BQN tutorial: https://mlochbaum.github.io/BQN/tutorial/index.html
Talk for Fullstack Academy by Gabriel Lebec: Lambda Calculus - Fundamentals of Lambda Calculus & Functional
Pragramming in JavaScript
https://www.youtube.com/watch?v=3VQ382QG-y4
David C Keenan
To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction
https://dkeenan.com/Lambda/
Haskell package data.aviary.birds:
https://hackage.haskell.org/package/data-aviary-0.4.0/docs/Data-Aviary-Birds.html
Bird names from Raymond M Smullyan. 2000. To Mock a Mockingbird: and other
logic puzzles including an amazing adventure in combinatory logic. Oxford
University Press, USA.
Combinator birds: https://www.angelfire.com/tx4/cus/combinator/birds.html