Functors contain nested definitions, much like <PRIVATE PRIVATE> blocks.
A new parser will be able to parse nested definitions unambigiously without
knowledge of the definition of <FUNCTOR: itself, which is not the case if
it looks like FUNCTOR: instead.
kernel math math.functions quotations ;
IN: alien.complex.functor
-FUNCTOR: define-complex-type ( N T -- )
+<FUNCTOR: define-complex-type ( N T -- )
N-type IS ${N}
complex >>boxed-class
drop
-;FUNCTOR
+;FUNCTOR>
TUPLE: alien-destructor alien ;
-FUNCTOR: define-destructor ( F -- )
+<FUNCTOR: define-destructor ( F -- )
F-destructor DEFINES-CLASS ${F}-destructor
<F-destructor> DEFINES <${F}-destructor>
: |F ( alien -- alien ) dup <F-destructor> |dispose drop ; inline
-;FUNCTOR
+;FUNCTOR>
SYNTAX: DESTRUCTOR: scan-word define-destructor ;
M: dataflow-analysis join-sets 2drop assoc-refine ;
M: dataflow-analysis ignore-block? drop kill-block?>> ;
-FUNCTOR: define-analysis ( name -- )
+<FUNCTOR: define-analysis ( name -- )
name DEFINES-CLASS ${name}
name-ins DEFINES ${name}-ins
: name-out ( bb -- set ) name-outs get at ;
-;FUNCTOR
+;FUNCTOR>
! ! ! Forward dataflow analysis
M: forward-analysis successors drop successors>> ;
M: forward-analysis predecessors drop predecessors>> ;
-FUNCTOR: define-forward-analysis ( name -- )
+<FUNCTOR: define-forward-analysis ( name -- )
name IS ${name}
name-ins IS ${name}-ins
name run-dataflow-analysis
[ name-ins set ] [ name-outs set ] bi* ;
-;FUNCTOR
+;FUNCTOR>
! ! ! Backward dataflow analysis
M: backward-analysis successors drop predecessors>> ;
M: backward-analysis predecessors drop successors>> ;
-FUNCTOR: define-backward-analysis ( name -- )
+<FUNCTOR: define-backward-analysis ( name -- )
name IS ${name}
name-ins IS ${name}-ins
\ name run-dataflow-analysis
[ name-outs set ] [ name-ins set ] bi* ;
-;FUNCTOR
+;FUNCTOR>
PRIVATE>
'[ [ _ ] dip changer-word [ ] 2sequence ] map [ ] join
[ drop ] append ;
-FUNCTOR: define-renaming ( NAME DEF-QUOT USE-QUOT TEMP-QUOT -- )
+<FUNCTOR: define-renaming ( NAME DEF-QUOT USE-QUOT TEMP-QUOT -- )
rename-insn-defs DEFINES ${NAME}-insn-defs
rename-insn-uses DEFINES ${NAME}-insn-uses
define
] each
-;FUNCTOR
+;FUNCTOR>
SYNTAX: RENAMING: scan-token scan-object scan-object scan-object define-renaming ;
<<
-FUNCTOR: define-box ( T -- )
+<FUNCTOR: define-box ( T -- )
B DEFINES-CLASS ${T}-box
<B> DEFINES <${B}>
C: <B> B ( T -- B )
-;FUNCTOR
+;FUNCTOR>
\ float define-box
[ execute ] [ execute ] bi ; inline
<<
-FUNCTOR: wrapper-test ( W -- )
+<FUNCTOR: wrapper-test ( W -- )
WW DEFINES ${W}${W}
: WW ( a -- b ) \ W twice ;
-;FUNCTOR
+;FUNCTOR>
\ sq wrapper-test
<<
-FUNCTOR: wrapper-test-2 ( W -- )
+<FUNCTOR: wrapper-test-2 ( W -- )
W DEFINES ${W}
: W ( a b -- c ) \ + execute ;
-;FUNCTOR
+;FUNCTOR>
"blah" wrapper-test-2
<<
-FUNCTOR: symbol-test ( W -- )
+<FUNCTOR: symbol-test ( W -- )
W DEFINES ${W}
SYMBOL: W
-;FUNCTOR
+;FUNCTOR>
"blorgh" symbol-test
<<
-FUNCTOR: generic-test ( W -- )
+<FUNCTOR: generic-test ( W -- )
W DEFINES ${W}
M: object W ;
M: integer W 1 + ;
-;FUNCTOR
+;FUNCTOR>
"snurv" generic-test
test-redefinition
-FUNCTOR: redefine-test ( W -- )
+<FUNCTOR: redefine-test ( W -- )
W-word DEFINES ${W}-word
W-tuple DEFINES-CLASS ${W}-tuple
M: W-tuple W-generic ;
SYMBOL: W-symbol
-;FUNCTOR
+;FUNCTOR>
[ [ ] ] [
"IN: functors.tests
<<
-FUNCTOR: define-a-struct ( T NAME TYPE N -- )
+<FUNCTOR: define-a-struct ( T NAME TYPE N -- )
T-class DEFINES-CLASS ${T}
{ z TYPE initial: 5 }
{ float { c:float 2 } } ;
-;FUNCTOR
+;FUNCTOR>
"a-struct" "nemo" c:char 2 define-a-struct
<<
-FUNCTOR: define-an-inline-word ( W -- )
+<FUNCTOR: define-an-inline-word ( W -- )
W DEFINES ${W}
W-W DEFINES ${W}-${W}
: W ( -- ) ; inline
: W-W ( -- ) W W ;
-;FUNCTOR
+;FUNCTOR>
"an-inline-word" define-an-inline-word
<<
-FUNCTOR: define-a-final-class ( T W -- )
+<FUNCTOR: define-a-final-class ( T W -- )
T DEFINES-CLASS ${T}
W DEFINES ${W}
: W ( -- ) ;
-;FUNCTOR
+;FUNCTOR>
"a-final-tuple" "a-word" define-a-final-class
SYNTAX: DEFINES-CLASS [ create-class-in ] (INTERPOLATE) ;
-DEFER: ;FUNCTOR delimiter
+DEFER: ;FUNCTOR> delimiter
<PRIVATE
functor-words [
"WHERE" parse-bindings drop
[ swap <def> suffix ] { } assoc>map concat
- \ ;FUNCTOR parse-until [ ] append-as
+ \ ;FUNCTOR> parse-until [ ] append-as
qualified-vocabs pop* ! unuse the bindings
] with-lambda-scope ;
-: (FUNCTOR:) ( -- word def effect )
+: (<FUNCTOR:) ( -- word def effect )
scan-new-word [ parse-functor-body ] parse-locals-definition ;
PRIVATE>
-SYNTAX: FUNCTOR: (FUNCTOR:) define-declared ;
+SYNTAX: <FUNCTOR: (<FUNCTOR:) define-declared ;
<<
<PRIVATE
-FUNCTOR: (define-simd-128-cord) ( A/2 A -- )
+<FUNCTOR: (define-simd-128-cord) ( A/2 A -- )
A-rep IS ${A/2}-rep
>A/2 IS >${A/2}
A-rep >>rep
\ A typedef
-;FUNCTOR
+;FUNCTOR>
: define-simd-128-cord ( A/2 T -- )
[ define-specialized-cord ]
! SIMD concrete type functor
-FUNCTOR: define-simd-128 ( T -- )
+<FUNCTOR: define-simd-128 ( T -- )
A DEFINES-CLASS ${T}
A-rep IS ${T}-rep
A-rep >>rep
\ A c:typedef
-;FUNCTOR
+;FUNCTOR>
SYNTAX: SIMD-128:
scan-token define-simd-128 ;
M: object cord-append
generic-cord boa ; inline
-FUNCTOR: define-specialized-cord ( T C -- )
+<FUNCTOR: define-specialized-cord ( T C -- )
T-cord DEFINES-CLASS ${C}
2dup [ T instance? ] both?
[ T-cord boa ] [ generic-cord boa ] if ; inline
-;FUNCTOR
+;FUNCTOR>
: cord-map ( cord quot -- cord' )
[ [ head>> ] dip call ]
USING: functors kernel math.order sequences sorting ;
IN: sorting.functor
-FUNCTOR: define-sorting ( NAME QUOT -- )
+<FUNCTOR: define-sorting ( NAME QUOT -- )
NAME<=> DEFINES ${NAME}<=>
NAME>=< DEFINES ${NAME}>=<
: NAME<=> ( obj1 obj2 -- <=> ) QUOT compare ;
: NAME>=< ( obj1 obj2 -- >=< ) NAME<=> invert-comparison ;
-;FUNCTOR
+;FUNCTOR>
M: byte-array nth-c-ptr <displaced-alien> ; inline
M: byte-array direct-like drop uchar <c-direct-array> ; inline
-FUNCTOR: define-array ( T -- )
+<FUNCTOR: define-array ( T -- )
A DEFINES-CLASS ${T}-array
<A> DEFINES <${A}>
M: A v*high [ * \ T heap-size neg shift ] 2map ; inline
-;FUNCTOR
+;FUNCTOR>
: specialized-array-vocab ( c-type -- vocab )
[
<PRIVATE
-FUNCTOR: define-vector ( T -- )
+<FUNCTOR: define-vector ( T -- )
V DEFINES-CLASS ${T}-vector
INSTANCE: V specialized-vector
INSTANCE: V growable
-;FUNCTOR
+;FUNCTOR>
: specialized-vector-vocab ( c-type -- vocab )
[
PRIVATE>
-FUNCTOR: define-tuple-array ( CLASS -- )
+<FUNCTOR: define-tuple-array ( CLASS -- )
CLASS IS ${CLASS}
INSTANCE: CLASS-array sequence
-;FUNCTOR
+;FUNCTOR>
SYNTAX: TUPLE-ARRAY: scan-word define-tuple-array ;
sequences.private ;
IN: vectors.functor
-FUNCTOR: define-vector ( V A <A> -- )
+<FUNCTOR: define-vector ( V A <A> -- )
<V> DEFINES <${V}>
>V DEFINES >${V}
INSTANCE: V growable
-;FUNCTOR
+;FUNCTOR>
[ { [ word? ] [ vocabulary>> "annotations" = ] } 1&& not ]
filter ;
-FUNCTOR: define-annotation ( NAME -- )
+<FUNCTOR: define-annotation ( NAME -- )
(NAME) DEFINES (${NAME})
!NAME DEFINES !${NAME}
: NAMEs. ( -- )
NAMEs sorted-definitions. ;
-;FUNCTOR
+;FUNCTOR>
CONSTANT: annotation-tags {
"XXX" "TODO" "FIXME" "BUG" "REVIEW" "LICENSE"
] unit-test
-{ } [ 15 <iota> { 3 5 1 } reshape drop ] unit-test
\ No newline at end of file
+{ } [ 15 <iota> { 3 5 1 } reshape drop ] unit-test
SLOT: (n)
SLOT: (vectored)
-FUNCTOR: define-vectored-accessors ( S>> S<< T -- )
+<FUNCTOR: define-vectored-accessors ( S>> S<< T -- )
WHERE
M: T S<<
[ (n)>> ] [ (vectored)>> S>> ] bi set-nth-unsafe ; inline
-;FUNCTOR
+;FUNCTOR>
PRIVATE>
GENERIC: struct-transpose ( structstruct -- ssttrruucctt )
GENERIC: vectored-element> ( elt -- struct )
-FUNCTOR: define-vectored-struct ( T -- )
+<FUNCTOR: define-vectored-struct ( T -- )
T-array [ T array-class-of ]
dup length [ nip <iota> ] [ drop ] [ nip (vectored-T) ] 2tri
[ [ [ nth ] [ set-nth ] bi-curry* bi ] 2curry each ] keep ; inline
-;FUNCTOR
+;FUNCTOR>
SYNTAX: VECTORED-STRUCT:
scan-word define-vectored-struct ;
<<
-FUNCTOR: (define-blas-matrix) ( TYPE T U C -- )
+<FUNCTOR: (define-blas-matrix) ( TYPE T U C -- )
VECTOR IS ${TYPE}-blas-vector
<VECTOR> IS <${TYPE}-blas-vector>
M: MATRIX pprint-delims
drop \ XMATRIX{ \ } ;
-;FUNCTOR
+;FUNCTOR>
: define-real-blas-matrix ( TYPE T -- )
<<
-FUNCTOR: (define-blas-vector) ( TYPE T -- )
+<FUNCTOR: (define-blas-vector) ( TYPE T -- )
<DIRECT-ARRAY> IS <direct-${TYPE}-array>
XCOPY IS ${T}COPY
M: VECTOR pprint-delims
drop \ XVECTOR{ \ } ;
-;FUNCTOR
+;FUNCTOR>
-FUNCTOR: (define-real-blas-vector) ( TYPE T -- )
+<FUNCTOR: (define-real-blas-vector) ( TYPE T -- )
VECTOR IS ${TYPE}-blas-vector
XDOT IS ${T}DOT
M: VECTOR Vasum
(prepare-nrm2) XASUM ;
-;FUNCTOR
+;FUNCTOR>
-FUNCTOR: (define-complex-blas-vector) ( TYPE C S -- )
+<FUNCTOR: (define-complex-blas-vector) ( TYPE C S -- )
VECTOR IS ${TYPE}-blas-vector
XDOTU IS ${C}DOTU
M: VECTOR Vasum
(prepare-nrm2) XXASUM ;
-;FUNCTOR
+;FUNCTOR>
: define-real-blas-vector ( TYPE T -- )
}
{ $slide "Functor for sorting"
{ $code
- "FUNCTOR: define-sorting ( NAME QUOT -- )
+ "<FUNCTOR: define-sorting ( NAME QUOT -- )
NAME<=> DEFINES ${NAME}<=>
NAME>=< DEFINES ${NAME}>=<
: NAME>=< ( obj1 obj2 -- >=< )
NAME<=> invert-comparison ;
-;FUNCTOR"
+;FUNCTOR>"
}
}
{ $slide "Example of sorting functor"
tokyo.alien.tcutil tokyo.utils vectors ;
IN: tokyo.assoc-functor
-FUNCTOR: define-tokyo-assoc-api ( T N -- )
+<FUNCTOR: define-tokyo-assoc-api ( T N -- )
DBGET IS ${T}get
DBPUT IS ${T}put
M: TYPE hashcode* assoc-hashcode ;
-;FUNCTOR
+;FUNCTOR>