Abuse filter log

Abuse Filter navigation (Home | Recent filter changes | Examine past edits | Abuse log)
Jump to navigation Jump to search
Details for log entry 9,607

12:41, 9 January 2026: Pstron (talk | contribs) triggered filter 9, performing the action "edit" on Poop:Poop. Actions taken: Warn; Filter description: require new users to introduce themselves (examine)

Changes made in edit

'''Poop''' is a [[functional programming|functional]] [[esoteric programming language]] created by pstron, where everything is a ''poop'' and computation happens by ''pooping'' into other ''poops''. It is based on [[lambda calculus]] with a minimal syntax centered around toilet humor metaphors. The language is implemented as an interpreter written in [[Haskell]].

==Overview==
Poop has no assignments, no mutable objects, and no traditional control structures. Instead, programs are built from three core primitives: <code>poop</code> (lambda abstraction), <code>pooping</code> (function application), and macro definitions. Execution proceeds via substitution, expanding macros and replacing parameters until a result is produced.

==Syntax==
===Tokens and Whitespace===
Tokens must be separated by whitespace (spaces, tabs, or newlines).

===Comments===
* Single‐line: <code>// comment</code>
* Multi‐line: <code>/* comment */</code>

===Identifiers===
* Variable names: lowercase letters and underscores (<code>[a-z_]+</code>).
* Macro names: any identifier that is not a valid variable name; commonly written in PascalCase. May include digits and symbols.

===Literals===
Literals are enclosed between <code>Po</code> and <code>op</code>. The content between them is taken literally.
* <code>Poop</code> → a single space.
* <code>Popoopop</code> → the string "poop" (used to avoid keyword interpretation).
* <code>PoHello Worldop</code> → "Hello World".

Literals are never expanded as macros or treated as keywords.

==Primitives==
===poop (abstraction)===
<pre>
poop ⟨param⟩ poops ⟨body⟩ qooq
</pre>
Creates a lambda abstraction. When applied, every occurrence of ⟨param⟩ in ⟨body⟩ is replaced with the argument.

===pooping (application)===
<pre>
pooping ⟨expr₁⟩ poopy ⟨expr₂⟩ qooq
</pre>
Applies ⟨expr₂⟩ to ⟨expr₁⟩. Evaluation is strict (applicative order).

===Macro definition===
<pre>
poop ⟨name⟩ is ⟨content⟩ qooq
</pre>
Defines ⟨name⟩ as a macro that expands to ⟨content⟩. Macros are non‑recursive and are expanded during execution.

==Built‑in macros==
===Input===
When encountered, the interpreter pauses and reads one line from the user. The line is parsed as Poop code and replaces the <code>Input</code> macro in the program. This allows the user to supply both data and code dynamically.

===Print===
<pre>
pooping Print poopy ⟨x⟩ qooq
</pre>
Evaluates ⟨x⟩, prints its string representation to standard output, and returns ⟨x⟩ unchanged (i.e., it behaves as the identity function with a side effect).

==Examples==
===Hello World===
<pre>
// Define a greeting macro
poop Greet is
poop name poops
Hello Poop name
qooq
qooq

// Print "Hello World"
pooping Print poopy
pooping Greet poopy World qooq
qooq
</pre>

===Church numerals===
<pre>
// Church numeral zero
poop 0 is
poop f poops poop x poops x qooq qooq
qooq

// Successor function
poop Succ is
poop n poops
poop f poops
poop x poops
pooping f poopy
pooping pooping n poopy f qooq poopy x qooq
qooq
qooq
qooq
qooq
qooq
</pre>

==Computational class==
Poop is [[Turing complete]] because it implements the untyped lambda calculus with macro expansion (which provides a form of recursion/composition). Church numerals and fixed‑point combinators can be expressed.

==Implementation==
The reference implementation is written in Haskell and available on [[GitHub]]: [https://github.com/pstron/poop pstron/poop]. The project is dual‑licensed under the MIT License and a custom "Poop License" that disclaims all liability.

==See also==
* [[Lambda calculus]]
* [[Functional programming]]
* [[Esoteric programming language]]

==External resources==
* [https://github.com/pstron/poop GitHub repository]
* [https://github.com/pstron/poop/blob/main/TPRM.md The Poop Reference Manual]

[[Category:Functional esoteric languages]]
[[Category:Languages]]
[[Category:2026]]
[[Category:Implemented]]

Action parameters

VariableValue
Edit count of the user (user_editcount)
0
Name of the user account (user_name)
'Pstron'
Age of the user account (user_age)
504
Page ID (page_id)
0
Page namespace (page_namespace)
0
Page title (without namespace) (page_title)
'Poop:Poop'
Full page title (page_prefixedtitle)
'Poop:Poop'
Action (action)
'edit'
Edit summary/reason (summary)
''
Old content model (old_content_model)
''
New content model (new_content_model)
'wikitext'
Old page wikitext, before the edit (old_wikitext)
''
New page wikitext, after the edit (new_wikitext)
''''Poop''' is a [[functional programming|functional]] [[esoteric programming language]] created by pstron, where everything is a ''poop'' and computation happens by ''pooping'' into other ''poops''. It is based on [[lambda calculus]] with a minimal syntax centered around toilet humor metaphors. The language is implemented as an interpreter written in [[Haskell]]. ==Overview== Poop has no assignments, no mutable objects, and no traditional control structures. Instead, programs are built from three core primitives: <code>poop</code> (lambda abstraction), <code>pooping</code> (function application), and macro definitions. Execution proceeds via substitution, expanding macros and replacing parameters until a result is produced. ==Syntax== ===Tokens and Whitespace=== Tokens must be separated by whitespace (spaces, tabs, or newlines). ===Comments=== * Single‐line: <code>// comment</code> * Multi‐line: <code>/* comment */</code> ===Identifiers=== * Variable names: lowercase letters and underscores (<code>[a-z_]+</code>). * Macro names: any identifier that is not a valid variable name; commonly written in PascalCase. May include digits and symbols. ===Literals=== Literals are enclosed between <code>Po</code> and <code>op</code>. The content between them is taken literally. * <code>Poop</code> → a single space. * <code>Popoopop</code> → the string "poop" (used to avoid keyword interpretation). * <code>PoHello Worldop</code> → "Hello World". Literals are never expanded as macros or treated as keywords. ==Primitives== ===poop (abstraction)=== <pre> poop ⟨param⟩ poops ⟨body⟩ qooq </pre> Creates a lambda abstraction. When applied, every occurrence of ⟨param⟩ in ⟨body⟩ is replaced with the argument. ===pooping (application)=== <pre> pooping ⟨expr₁⟩ poopy ⟨expr₂⟩ qooq </pre> Applies ⟨expr₂⟩ to ⟨expr₁⟩. Evaluation is strict (applicative order). ===Macro definition=== <pre> poop ⟨name⟩ is ⟨content⟩ qooq </pre> Defines ⟨name⟩ as a macro that expands to ⟨content⟩. Macros are non‑recursive and are expanded during execution. ==Built‑in macros== ===Input=== When encountered, the interpreter pauses and reads one line from the user. The line is parsed as Poop code and replaces the <code>Input</code> macro in the program. This allows the user to supply both data and code dynamically. ===Print=== <pre> pooping Print poopy ⟨x⟩ qooq </pre> Evaluates ⟨x⟩, prints its string representation to standard output, and returns ⟨x⟩ unchanged (i.e., it behaves as the identity function with a side effect). ==Examples== ===Hello World=== <pre> // Define a greeting macro poop Greet is poop name poops Hello Poop name qooq qooq // Print "Hello World" pooping Print poopy pooping Greet poopy World qooq qooq </pre> ===Church numerals=== <pre> // Church numeral zero poop 0 is poop f poops poop x poops x qooq qooq qooq // Successor function poop Succ is poop n poops poop f poops poop x poops pooping f poopy pooping pooping n poopy f qooq poopy x qooq qooq qooq qooq qooq qooq </pre> ==Computational class== Poop is [[Turing complete]] because it implements the untyped lambda calculus with macro expansion (which provides a form of recursion/composition). Church numerals and fixed‑point combinators can be expressed. ==Implementation== The reference implementation is written in Haskell and available on [[GitHub]]: [https://github.com/pstron/poop pstron/poop]. The project is dual‑licensed under the MIT License and a custom "Poop License" that disclaims all liability. ==See also== * [[Lambda calculus]] * [[Functional programming]] * [[Esoteric programming language]] ==External resources== * [https://github.com/pstron/poop GitHub repository] * [https://github.com/pstron/poop/blob/main/TPRM.md The Poop Reference Manual] [[Category:Functional esoteric languages]] [[Category:Languages]] [[Category:2026]] [[Category:Implemented]]'
Unified diff of changes made by edit (edit_diff)
'@@ -1,0 +1,110 @@ +'''Poop''' is a [[functional programming|functional]] [[esoteric programming language]] created by pstron, where everything is a ''poop'' and computation happens by ''pooping'' into other ''poops''. It is based on [[lambda calculus]] with a minimal syntax centered around toilet humor metaphors. The language is implemented as an interpreter written in [[Haskell]]. + +==Overview== +Poop has no assignments, no mutable objects, and no traditional control structures. Instead, programs are built from three core primitives: <code>poop</code> (lambda abstraction), <code>pooping</code> (function application), and macro definitions. Execution proceeds via substitution, expanding macros and replacing parameters until a result is produced. + +==Syntax== +===Tokens and Whitespace=== +Tokens must be separated by whitespace (spaces, tabs, or newlines). + +===Comments=== +* Single‐line: <code>// comment</code> +* Multi‐line: <code>/* comment */</code> + +===Identifiers=== +* Variable names: lowercase letters and underscores (<code>[a-z_]+</code>). +* Macro names: any identifier that is not a valid variable name; commonly written in PascalCase. May include digits and symbols. + +===Literals=== +Literals are enclosed between <code>Po</code> and <code>op</code>. The content between them is taken literally. +* <code>Poop</code> → a single space. +* <code>Popoopop</code> → the string "poop" (used to avoid keyword interpretation). +* <code>PoHello Worldop</code> → "Hello World". + +Literals are never expanded as macros or treated as keywords. + +==Primitives== +===poop (abstraction)=== +<pre> +poop ⟨param⟩ poops ⟨body⟩ qooq +</pre> +Creates a lambda abstraction. When applied, every occurrence of ⟨param⟩ in ⟨body⟩ is replaced with the argument. + +===pooping (application)=== +<pre> +pooping ⟨expr₁⟩ poopy ⟨expr₂⟩ qooq +</pre> +Applies ⟨expr₂⟩ to ⟨expr₁⟩. Evaluation is strict (applicative order). + +===Macro definition=== +<pre> +poop ⟨name⟩ is ⟨content⟩ qooq +</pre> +Defines ⟨name⟩ as a macro that expands to ⟨content⟩. Macros are non‑recursive and are expanded during execution. + +==Built‑in macros== +===Input=== +When encountered, the interpreter pauses and reads one line from the user. The line is parsed as Poop code and replaces the <code>Input</code> macro in the program. This allows the user to supply both data and code dynamically. + +===Print=== +<pre> +pooping Print poopy ⟨x⟩ qooq +</pre> +Evaluates ⟨x⟩, prints its string representation to standard output, and returns ⟨x⟩ unchanged (i.e., it behaves as the identity function with a side effect). + +==Examples== +===Hello World=== +<pre> +// Define a greeting macro +poop Greet is + poop name poops + Hello Poop name + qooq +qooq + +// Print "Hello World" +pooping Print poopy + pooping Greet poopy World qooq +qooq +</pre> + +===Church numerals=== +<pre> +// Church numeral zero +poop 0 is + poop f poops poop x poops x qooq qooq +qooq + +// Successor function +poop Succ is + poop n poops + poop f poops + poop x poops + pooping f poopy + pooping pooping n poopy f qooq poopy x qooq + qooq + qooq + qooq + qooq +qooq +</pre> + +==Computational class== +Poop is [[Turing complete]] because it implements the untyped lambda calculus with macro expansion (which provides a form of recursion/composition). Church numerals and fixed‑point combinators can be expressed. + +==Implementation== +The reference implementation is written in Haskell and available on [[GitHub]]: [https://github.com/pstron/poop pstron/poop]. The project is dual‑licensed under the MIT License and a custom "Poop License" that disclaims all liability. + +==See also== +* [[Lambda calculus]] +* [[Functional programming]] +* [[Esoteric programming language]] + +==External resources== +* [https://github.com/pstron/poop GitHub repository] +* [https://github.com/pstron/poop/blob/main/TPRM.md The Poop Reference Manual] + +[[Category:Functional esoteric languages]] +[[Category:Languages]] +[[Category:2026]] +[[Category:Implemented]] '
New page size (new_size)
4008
Old page size (old_size)
0
Lines added in edit (added_lines)
[ 0 => ''''Poop''' is a [[functional programming|functional]] [[esoteric programming language]] created by pstron, where everything is a ''poop'' and computation happens by ''pooping'' into other ''poops''. It is based on [[lambda calculus]] with a minimal syntax centered around toilet humor metaphors. The language is implemented as an interpreter written in [[Haskell]].', 1 => '', 2 => '==Overview==', 3 => 'Poop has no assignments, no mutable objects, and no traditional control structures. Instead, programs are built from three core primitives: <code>poop</code> (lambda abstraction), <code>pooping</code> (function application), and macro definitions. Execution proceeds via substitution, expanding macros and replacing parameters until a result is produced.', 4 => '', 5 => '==Syntax==', 6 => '===Tokens and Whitespace===', 7 => 'Tokens must be separated by whitespace (spaces, tabs, or newlines).', 8 => '', 9 => '===Comments===', 10 => '* Single‐line: <code>// comment</code>', 11 => '* Multi‐line: <code>/* comment */</code>', 12 => '', 13 => '===Identifiers===', 14 => '* Variable names: lowercase letters and underscores (<code>[a-z_]+</code>).', 15 => '* Macro names: any identifier that is not a valid variable name; commonly written in PascalCase. May include digits and symbols.', 16 => '', 17 => '===Literals===', 18 => 'Literals are enclosed between <code>Po</code> and <code>op</code>. The content between them is taken literally.', 19 => '* <code>Poop</code> → a single space.', 20 => '* <code>Popoopop</code> → the string "poop" (used to avoid keyword interpretation).', 21 => '* <code>PoHello Worldop</code> → "Hello World".', 22 => '', 23 => 'Literals are never expanded as macros or treated as keywords.', 24 => '', 25 => '==Primitives==', 26 => '===poop (abstraction)===', 27 => '<pre>', 28 => 'poop ⟨param⟩ poops ⟨body⟩ qooq', 29 => '</pre>', 30 => 'Creates a lambda abstraction. When applied, every occurrence of ⟨param⟩ in ⟨body⟩ is replaced with the argument.', 31 => '', 32 => '===pooping (application)===', 33 => '<pre>', 34 => 'pooping ⟨expr₁⟩ poopy ⟨expr₂⟩ qooq', 35 => '</pre>', 36 => 'Applies ⟨expr₂⟩ to ⟨expr₁⟩. Evaluation is strict (applicative order).', 37 => '', 38 => '===Macro definition===', 39 => '<pre>', 40 => 'poop ⟨name⟩ is ⟨content⟩ qooq', 41 => '</pre>', 42 => 'Defines ⟨name⟩ as a macro that expands to ⟨content⟩. Macros are non‑recursive and are expanded during execution.', 43 => '', 44 => '==Built‑in macros==', 45 => '===Input===', 46 => 'When encountered, the interpreter pauses and reads one line from the user. The line is parsed as Poop code and replaces the <code>Input</code> macro in the program. This allows the user to supply both data and code dynamically.', 47 => '', 48 => '===Print===', 49 => '<pre>', 50 => 'pooping Print poopy ⟨x⟩ qooq', 51 => '</pre>', 52 => 'Evaluates ⟨x⟩, prints its string representation to standard output, and returns ⟨x⟩ unchanged (i.e., it behaves as the identity function with a side effect).', 53 => '', 54 => '==Examples==', 55 => '===Hello World===', 56 => '<pre>', 57 => '// Define a greeting macro', 58 => 'poop Greet is', 59 => ' poop name poops', 60 => ' Hello Poop name', 61 => ' qooq', 62 => 'qooq', 63 => '', 64 => '// Print "Hello World"', 65 => 'pooping Print poopy', 66 => ' pooping Greet poopy World qooq', 67 => 'qooq', 68 => '</pre>', 69 => '', 70 => '===Church numerals===', 71 => '<pre>', 72 => '// Church numeral zero', 73 => 'poop 0 is', 74 => ' poop f poops poop x poops x qooq qooq', 75 => 'qooq', 76 => '', 77 => '// Successor function', 78 => 'poop Succ is', 79 => ' poop n poops', 80 => ' poop f poops', 81 => ' poop x poops', 82 => ' pooping f poopy', 83 => ' pooping pooping n poopy f qooq poopy x qooq', 84 => ' qooq', 85 => ' qooq', 86 => ' qooq', 87 => ' qooq', 88 => 'qooq', 89 => '</pre>', 90 => '', 91 => '==Computational class==', 92 => 'Poop is [[Turing complete]] because it implements the untyped lambda calculus with macro expansion (which provides a form of recursion/composition). Church numerals and fixed‑point combinators can be expressed.', 93 => '', 94 => '==Implementation==', 95 => 'The reference implementation is written in Haskell and available on [[GitHub]]: [https://github.com/pstron/poop pstron/poop]. The project is dual‑licensed under the MIT License and a custom "Poop License" that disclaims all liability.', 96 => '', 97 => '==See also==', 98 => '* [[Lambda calculus]]', 99 => '* [[Functional programming]]', 100 => '* [[Esoteric programming language]]', 101 => '', 102 => '==External resources==', 103 => '* [https://github.com/pstron/poop GitHub repository]', 104 => '* [https://github.com/pstron/poop/blob/main/TPRM.md The Poop Reference Manual]', 105 => '', 106 => '[[Category:Functional esoteric languages]]', 107 => '[[Category:Languages]]', 108 => '[[Category:2026]]', 109 => '[[Category:Implemented]]' ]
Unix timestamp of change (timestamp)
'1767962464'
Retrieved from "https://esolangs.org/wiki/Special:AbuseLog/9607"