Perl6 thread

This code will show you the truth of Perl6


perl -e 'print "Perl6 has an operator for $_" foreach (qx[cat /usr/dict/words]);'

/prog/ will be spammed continuously until further notice. we apologize for any inconvenience this may cause.

bumping for interesting thread

checkem 6's

I prefer Perl5. There is no type.

>>1
Symta: say: [1 2 3 4 5] fold: A B => A+B

Perl:  say (1,2,3,4,5).reduce: { $^a + $^b };

Perl: https://github.com/perl6/std/blob/master/STD.pm6

Symta:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;; READER

(defparameter  /base   nil)   ; beginning of input stream
(defparameter  /in     nil)   ; current position inside input
(defparameter  /src    nil)   ; source, from where input comes
(defparameter  /res    nil)   ; result
(defparameter  /row    nil)   ; current row
(defparameter  /col    nil)   ; current column
(defparameter  /off    nil)   ; current offset inside input
(defparameter  /last   nil)   ; last processed char

(to /error msg ! error "{/src}:{/row},{/col}: {msg}")

(to /top-char ! car /in)

(to /next-char
  ! c = (/top-char)
  ! if eq c #\newline
  ! ! do (setf /col 0)
         (incf /row)
  ! ! incf /col
  ! incf /off
  ! setf /last c
  ! setf /in (cdr /in)
  ! c)

(to /skip-ws
  ! c = (/top-char)
  ! cond
  ! ! find c '(#\space #\newline)
  ! ! ! (/next-char)
  ! ! ! (/skip-ws)
  ! ! and (eq c #\/) (eq (second /in) #\/)
  ! ! ! (/next-char)
  ! ! ! (/next-char)
  ! ! ! while and (/top-char) (not (eq (/top-char) #\newline))
  ! ! ! ! (/next-char)
  ! ! ! (/skip-ws)
  ! ! and (eq c #\/) (eq (second /in) #\*)
  ! ! ! (/next-char)
  ! ! ! (/next-char)
  ! ! ! o = 1
  ! ! ! while plusp o
  ! ! ! ! unless /in
  ! ! ! ! ! /error "`/*`: missing `*/`"
  ! ! ! ! a = (/next-char)
  ! ! ! ! b = first /in
  ! ! ! ! cond
  ! ! ! ! ! and (eql a #\*) (eql b #\/) :> (! (/next-char) ! decf o)
  ! ! ! ! ! and (eql a #\/) (eql b #\*) :> (! (/next-char) ! incf o)
  ! ! ! (/skip-ws)
  )

(to /take-prefix p
  ! rec r ys nil
  ! ! y = (/top-char)
  ! ! if funcall p y
  ! ! ! r (cons (/next-char) ys)
  ! ! ! nreverse ys)

(to /location match
  ! l = length match
  ! list
  ! ! list "Col" (- /col l)
  ! ! list "Off" (- /off l)
  ! ! list "Row" /row
  ! ! list "Src" /src)

(to /expect c
  ! if eq (/top-char) c
  ! ! (/next-char)
  ! ! /error "Expected `{c}`; Got `{or (/top-char) 'EOF}`")

(defmacro try ((var expr fail) &body body)
  `(! ,var = ,expr
    ! if eq ,var :fail
    ! ! ,fail
    ! ! do ,@body))

(to str-empty? o ! and (quote? o) (equal (second o) ""))

(to interp l e r ; interpolate expression into string
  ! l = (! if str-empty? l
         ! ! list "\"" e
         ! ! list "\"" l e)
  ! unless str-empty? r
  ! ! setf l (! if headed "\"" r
              ! ! q ''l ''(cdr r)
              ! ! q ''l ''(list r))
  ! l)

(to /read-string ic d s e
  ! l = nil
  ! while t
  ! ! c = (/top-char)
  ! ! unless eq c ic :> (/next-char)
  ! ! cond
  ! ! ! eq c #\\
  ! ! ! ! setf c (/next-char)
  ! ! ! ! cond
  ! ! ! ! ! eq c #\n :> push #\newline l
  ! ! ! ! ! eq c #\t :> push #\tab l
  ! ! ! ! ! eq c #\\ :> push #\\ l
  ! ! ! ! ! or (eq c #\n) (eq c ic) (eq c e) (eq c s) :> push c l
  ! ! ! ! ! eq c nil :> /error "EOF in string"
  ! ! ! ! ! or t :> /error "Invalid escape code: {c}"
  ! ! ! eq c s
  ! ! ! ! incf d
  ! ! ! ! push c l
  ! ! ! eq c e
  ! ! ! ! decf d
  ! ! ! ! if < d 0
  ! ! ! ! ! return-from /read-string (list "\\" (coerce (reverse l) 'string))
  ! ! ! ! ! push c l
  ! ! ! eq c ic ;interpolate
  ! ! ! ! try it (/term) (/error "`[`: missing argument")
  ! ! ! ! ! r = /read-string ic d s e
  ! ! ! ! ! return-from /read-string (interp (list "\\" (coerce (reverse l) 'string)) (cdr it) r)
  ! ! ! eq c nil :> /error "EOF in string"
  ! ! ! or t :> push c l
  )

(to /string
  ! case (/top-char)
  ! ! #\" (/next-char) (/read-string #[ 0 nil #\")
  ! ! #\' (/next-char) (/read-string #[ 0 nil #\')
  ! ! #\` (second (/read-string nil 0 nil (/next-char)))
  ! ! otherwise :fail)

(to /list &key r-op
  ! opening = (/top-char)
  ! op = (or r-op
             (find-if (fn (x) (eq (char x 0) opening))
                      '("()" "[]"))
             (return-from /list (/string)))
  ! ending = aref op 1
  ! row = nil
  ! col = nil
  ! setf row /row
  ! setf col /col
  ! unless r-op :> /expect opening
  ! rec r xs nil
  ! ! try x (/expr) (! if eq (/top-char) ending
                     ! ! (/next-char)
                     ! ! error "{/src}:{row},{col}: unclosed `{opening}`"
                     ;;! (meta-set (ns-set nil "Src" (/location nil)) xs)
                     ! xs = nreverse xs
                     ! when string= op "[]" :> setf xs (q "list" ''xs)
                     ! xs)
  ! ! ! r (cons x xs)
  )

(to hex-digit? x ! or (digit? x) (find x "abcdefABCDEF"))

(to /num
  ! cond
  ! ! digit? (/top-char)
  ! ! ! rec r i t
              ys nil
  ! ! ! ! y = (/top-char)
  ! ! ! ! cond
  ! ! ! ! ! and (eql y #\.) i (digit? (second /in)) :> r nil (cons (/next-char) ys)
  ! ! ! ! ! digit? y :> r i (cons (/next-char) ys)
  ! ! ! ! ! or t :> read-from-string (coerce (nreverse ys) 'string)
  ! ! eq (/top-char) #\#
  ! ! ! /expect #\#
  ! ! ! when eq (/top-char) #\{ :> return-from /num (list "#" (second (/list)))
  ! ! ! when /sym-body? (/top-char)
  ! ! ! ! s = coerce (/take-prefix #'/sym-body?) 'string
  ! ! ! ! when hex-digit? (aref s 0) :> return-from /num (read-from-string (concatenate 'string "#x" s))
  ! ! ! ! when string= s "yes" :> return-from /num :yes
  ! ! ! ! when string= s "no" :> return-from /num :no
  ! ! ! ! when string= s "void" :> return-from /num :void
  ! ! ! ! when string= s "head" :> return-from /num :head
  ! ! ! ! /error "`#{s}` is unexpected"
  ! ! ! /error "`#{(/top-char)}` is unexpected"
  ! ! or t :> :fail)

(to /delim
  ! (/skip-ws)
  ! c = assoc (/top-char) '((#\| :|\||) (#\: :|:|) (#\; :|;|))
  ! unless c :> return-from /delim (/list)
  ! (/next-char)
  ! second c)

(to /term
  ! (/skip-ws)
  ! x = (/top-char)
  ! if /sym-head? x
  ! ! coerce (/take-prefix #'/sym-body?) 'string
  ! ! try n (/num) (/delim)
  ! ! ! when /sym-head? (/top-char)
  ! ! ! ! setf n (list "*" n (/dot))
  ! ! ! n)

(defun left-curly () "{")
(defun curly-braces () "{}")

(to delim? x ! find x '(:|\|| :|:| "=" "=>") :test 'equal)

(to /op &rest ops
  ! (/skip-ws)
  ! c = (/top-char)
  ! when or (alpha? c) (digit? c) (not (find c ops))
  ! ! return-from /op :fail
  ! string (/next-char))

(defmacro /lop (name down &rest ops) ; left-biased op
  `(to ,name
     ! try a (,down) :fail
     ! ! rec r e a
     ! ! ! try o (/op ,@ops) e
     ! ! ! ! if string= o (left-curly)
     ! ! ! ! ! do
     ! ! ! ! ! ! xs = /list :r-op (curly-braces)
     ! ! ! ! ! ! when find-if #'delim? xs :> setf xs (list xs)
     ! ! ! ! ! ! r (q '(curly-braces) 'e ''xs)
     ! ! ! ! ! try b (,down) (/error "`{o}`: missing right operand")
     ! ! ! ! ! ! r (list o e b)))

(defmacro /rop (name down &rest ops) ; right-biased op
  `(to ,name
     ! try a (,down) :fail
     ! ! try o (/op ,@ops) a
     ! ! ! try b (,name) (/error "`{o}`: missing right operand")
     ! ! ! ! list o a b))


(defmacro /prop (name down &rest ops) ; prefix op
  `(to ,name
     ! try o (/op ,@ops) (,down)
     ! ! try a (,name) (/error "`{o}`: missing operand")
     ! ! ! if and (numberp a) (equal o "~") ;dangerous hack
     ! ! ! ! - a
     ! ! ! ! list o a))

(/prop /gs   /term #\^)
(/lop  /dot  /gs   #\. #\, #\{)
(/prop /pref /dot  #\~ #\\ #\$ #\! #\@ #\&)
(/lop  /mul  /pref #\* #\/ #\%)
(/lop  /add  /mul  #\+ #\-)

(to /expr ! (/add))

(to /line
  ! rec r xs nil
  ! ! try x (/expr) (! if-bind it (/top-char) (/error "Unexpected `{it}`")
                     ! nreverse xs)
  ! ! ! push x xs
  ! ! ! (/skip-ws)
  ! ! ! if and (eq /last #\newline) (not (eq (/top-char) #\|))
  ! ! ! ! nreverse xs
  ! ! ! ! r xs)

(to head-args? xs ! headed :head xs)
(to head-args-as-list xs ! if (headed :head xs) (cdr xs) xs)
(to list-as-head-args &rest xs ! q :head ''xs)

(to sioc xs ; processes symta indentation of code
  ! unless listp xs :> return-from sioc xs
  ! p = position-if #'delim? xs
  ! unless p
  ! ! unless headed :|\|| xs :> setf xs (mapcar #'sioc xs)
  ! ! return-from sioc xs
  ! text = elt xs p
  ! pref = subseq xs 0 p
  ! xs = subseq xs p (length xs)
  ! body = cdr xs
  ! zs = nil
  ! when equal text "=>" :> return-from sioc (sioc `("to" ,@pref :|:| ,@body))
  ! when equal text "=" :> return-from sioc (sioc `("my" ,@pref :|:| ,@body))
  ! when equal text :|:|
  ! ! pref = or pref '(:void)
  ! ! return-from sioc (sioc (q '(car pref) (:head ''(cdr pref)) '(sioc body)))
  ! while xs
  ! ! pop xs
  ! ! ys = nil
  ! ! while equal (car xs) :|\|| :> push (pop xs) ys
  ! ! while and xs (not (equal (car xs) :|\||)) :> push (pop xs) ys
  ! ! ys = nreverse ys
  ! ! if equal (car ys) :|\||
  ! ! ! push (append (pop zs) ys) zs
  ! ! ! push ys zs
  ! xs = map xs (nreverse zs) :> sioc xs
  ! if pref
  ! ! q '(car pref) (:head ''(cdr pref)) ''xs
  ! ! q do ''xs)

(to /read-toplevel xs src
  ! unless listp xs :> setf xs (coerce xs 'list)
  ! /src = src
  ! /base = xs
  ! /in = /base
  ! /off = 0
  ! /row = 0
  ! /col = 0
  ! /last = nil
  ! r = nil
  ! while /in
  ! ! l = (/line)
  ! ! when xs? l :> push (sioc l) r
  ! nreverse r)

(to /read xs ! first (/read-toplevel xs "<REPL>"))

>>69
You've managed to make a language uglier than Perl, congratulations.

>>69












               !

              !


  !
  !
  ! !

  ! !
  !
  !
  !
  !


  !
  !
  ! !
  ! ! !
  ! ! !
  ! !
  ! ! !
  ! ! !
  ! ! !
  ! ! ! !
  ! ! !
  ! !
  ! ! !
  ! ! !
  ! ! !
  ! ! !
  ! ! ! !
  ! ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! ! !                                 !              !
  ! ! ! ! !                                 !              !
  ! ! !



  !
  ! !
  ! !
  ! ! !
  ! ! !


  !
  !
  ! !
  ! !
  ! !
  ! !


  !
  ! !
  ! !


    !
    !
    ! !
    ! !

                 !


  !      !
         ! !
         ! !
  !
  ! !         !
              ! !
              ! !
  !


  !
  !
  ! !
  ! !
  ! !
  ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! !
  ! ! ! !
  ! ! ! !
  ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! !
  ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! !
  ! ! !



  !
  ! !
  ! !
  ! !
  ! !


  !
  !



  !
  !
  !
  !
  !
  !
  !
  ! !                !
                     ! !
                     ! !
                       !
                     !
                     !
                     !
  ! ! !


                 !


  !
  ! !
  ! ! !

  ! ! ! !
  ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! ! ! ! !
  ! !
  ! ! !
  ! ! !
  ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! ! !
  ! ! !
  ! !


  !
  !
  !
  !
  !


  !
  !
  !
  ! !
  ! !
  ! ! !
  ! ! ! !
  ! ! !




             !


  !
  !
  !
  ! !
  !



     !
     ! !
     ! ! !
     ! ! ! !
     ! ! ! ! !
     ! ! ! ! ! !
     ! ! ! ! ! !
     ! ! ! ! ! !
     ! ! ! ! !
     ! ! ! ! ! !



     !
     ! !
     ! ! !
     ! ! ! !




     !
     ! !
     ! ! !
     ! ! ! !
     ! ! ! !



                                 !



          !


  !
  ! !                !
                     !
  ! ! !
  ! ! !
  ! ! !
  ! ! ! !
  ! ! ! !

                  !
                         !
                               !


  !
  !
  !
  ! !
  ! !
  !
  !
  !
  !
  !
  !
  !
  !
  ! !
  ! !
  !
  ! !
  ! !
  ! !
  ! !
  ! !
  ! !
  ! ! !
  ! ! !
  !
  !
  ! !
  ! !


  !
  !
  !
  !
  !
  !
  !
  !
  !
  !
  ! !
  ! !
  !

             !

I still don't understand the purpose of the fucking !s, Jew. Must be a Jew thing.

Shalom, Nikita!

>>70>>71>>72

This talk is about why Perl 5 sucks (although Perl 6 became arguably worser, just it's grammar file is about 6500 lines: https://github.com/perl6/std/blob/master/STD.pm6).
- Abominable syntax: Perl's syntax is so non-orthogonal and hideous, it shades all other Perl warts (which are ugly). Perl's grammar isn't context free and can not be reduced to BNF. Perl's parser (perly.y) is 760 lines long (larger than C++ and Haskell), while the lexer (toke.c) is 11000 lines long, which gives a clue how many kludges Perl needs that the parser can't handle itself. Perl grammar is inherently ambiguous, and the resolved by using dodgy look-ahead heuristics. For example, is "print $f +$g" writing the positive value $g to the file $f, or printing ($f+$g) to STDOUT? Does `{ local $a => 1; ... "` start a scope block or a hash? Other example `f / 25 ; # / ; die "oops!";` can parse two different ways: if `f` takes no arguments, then first statement is a division in void context, and the rest of the line is a comment, otherwise it parses as a call to f() with the result of a match operator, then a call to die(). In general, Perl cannot be parsed, because Perl's syntax is undecidable: http://www.perlmonks.org/?node_id=663393
- Broken scoping: Perl doesn't require variables to be declared and just referencing a name introduces a variable, resulting into cluttered global scope and absence of undefined-variable warnings. Although Perl has my and local keywords, they are not enforced, so nobody uses them. All variables have to be prefixed with ugly $ @ % & sigils all time, just to disambiguate in case variable doesn't already hold a value. It is typical to see crazy code, like "my $fh = do {local(*FH);};", which creates a local typeglob named FH and immediately takes it out of scope, returning the now anonymous typeglob. Perl's broken scoping is a fundamental flaw, which cannot be fixed.
- Inconsistent type system: Perl implicitly coerces strings to integers, so "123abc"=="123def" and "  123xyz"==123, and even 0.0=="". Sigils everywhere make type system depend on scoping. No OOP encapsulation or overloading: Perl has a mess of unorganized global functions. Most typing mismatches, instead of generating error, return some nonsense value, so void+123 or @x+%y==0 would give you untraceable bug. Finally, Perl has no booleans, so there is no way to discern 0 from false; moreover "" and "0" are false too, but "00" isn't, despite "0"=="00". For some reason void acts as true, but referencing undefined variable returns false. Integers are represented as floating point values, so 99999999999999999999==100000000000000000000.
- Perl is hard to learn, due to non-orthogonality by design: Perl's goal of bundling basic Unix utilities into one language was achieved in haste, ending up producing numerous sublanguages loosely glued together, making Perl look like a deficient Unix clone, where all commands are builtins. Perl implements a lot of standard library on syntax level, making language enormous in size: for example, instead of being a library function, regular expressions are implemented as syntactic construct, allowed at unexpected places, like in "print if /regex/", which also gives no clue what it prints or takes as input. Or take "pos($x) = pos($x)", which does bizarre magic at resetting regex. Other example is ".." operator: "print 1..3" produces a sequence, but "print if 1..3" interpret 1..3 as a range of input lines. Then Perl has a lot of duplication: for example, Perl has `not` operator, but for some reason also includes `!` and `unless`, while keyword `if` is overloaded as infix operator, and don't forger about cryptic if?then:else operator. Having a myriad of these special cases, Perl rejects logic and appeals to humanities and theology students, who love learning random facts by rote memorization, and for whom $_ and <> are perfectly clear, even intuitive. The standard Perl documentation contains over 70,000 lines, add to that all the documentation on CPAN modules, and you face a pretty substantial base of prose just to begin with Perl. "Perl users were unable to write programs more accurately than those using a language designed by chance." -- http://ecs.victoria.ac.nz/twiki/pub/Events/PLATEAU/Program/plateau2011-stefik.pdf
- Perl is inefficient: broken scoping impedes efficient compilation and bad type system hinders any optimization, making Perl agonizingly slow. Aggravating Perl's condition are naive reference counting garbage collector and unparsable syntax, requiring solving halting problem just to parse a Perl source file.
- Perl code is unmaintainable, "clever", unreadable and obfuscated: Perl encourages packing unrelated concepts into a messy one-liner, impeding understanding and modification; TIMTOWTDI-redundancy guarantees style discrepancies, misunderstanding and pointless flame-wars among developers, which is aggravated by the size of the language. Finally, Perl isn't modular: it is common to see Perl script 6000 lines long.

! ! Shalom!

! ! molahS

>>75
Valid Symta code

>>72
CP payload, silly.

>>6
http://perlcabal.org/syn/S03.html
cabal
http://en.wikipedia.org/wiki/Cabal
The term cabal derives from Cabala (a word that has numerous spelling variations), the Jewish mystical interpretation of the Hebrew scripture.
Shalom, Hymie!

Perl is now officially Jewish. And Larry Wall is a crazy kike, obsessed with Bible and Apocalypsis.

>>31
Symta (works, because lowercase symbols are literal string):
A = "abcdef";
B = A map: a => z
say A // abcdef
say B // zbcdef

Perl6:
my $a = "abcdef";
my $b = $a.map: { ~~ s/a/z/; $_ }
say $a; # abcdef
say $b; # zbcdef

>>79
A = "abcdef";
And I forget to remove the `;`