Examine individual changes
This page allows you to examine the variables generated by the Abuse Filter for an individual change.
Variables generated for this change
| Variable | Value |
|---|---|
Edit count of the user (user_editcount) | 0 |
Name of the user account (user_name) | 'MRX' |
Age of the user account (user_age) | 14866304 |
Page ID (page_id) | 0 |
Page namespace (page_namespace) | 2 |
Page title (without namespace) (page_title) | 'MRX' |
Full page title (page_prefixedtitle) | 'User:MRX' |
Action (action) | 'edit' |
Edit summary/reason (summary) | 'still in development' |
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) | 'Loom
Concept:
Loom is based on weaving strings of characters, and each "thread" (a string of characters) has its own significance. The language operates by manipulating these strings, weaving new ones, and unweaving them to produce results.
Key Ideas:
String as the Core Data Type:
The primary datatype in Loom is a string of characters, which represents a "thread."
Strings are manipulated by performing various "weaving" operations: adding, removing, or combining threads.
Thread Operations:
Weave: You combine two or more strings (threads) into a new string.
Unweave: You separate a string into parts, either by position or pattern matching.
Cut: You remove a portion of the string, essentially "cutting" a thread at a specific location.
Twist: Change the character order of a string by shifting it around (like a rotation).
Knot: Tie two strings together, making them dependent on each other. The strings interact in the same order, and modifying one can affect the other.
Commands:
weave a b: Combine the strings a and b into a new string.
unweave a n: Break down string a into n parts.
cut a n: Remove the n-th character from string a.
twist a: Rotate string a by one position (a "shift" operation).
knot a b: Link strings a and b together in a dynamic, dependent relationship.
Memory Representation:
The strings (threads) are stored in a "loom" (an array-like structure).
Operations modify the loom's state. These states can be logged and viewed as the program executes, much like the changing pattern of a woven cloth.
Output:
The output of the program is the final form of a string (or series of strings) after all weaving operations are done.
If the program successfully weaves a specific pattern or structure, it outputs it; otherwise, it indicates failure to achieve the pattern.
Example Code:
weave "Hello" "World"
twist "HelloWorld"
cut "HelloWorld" 5
knot "Hello" "World"
Example Explanation:
First, the program combines "Hello" and "World" into a new string.
Then, the string is twisted (rotated one character).
The program cuts the string at the 5th position, splitting "HelloWorld" into two parts.
Lastly, "Hello" and "World" are knotted together, which means they are now linked in a dynamic way—modifying one part might affect the other.
Potential Use Cases:
Creative text manipulation.
Generating patterns and sequences.
Creating puzzles or challenges where the goal is to achieve a specific string through a series of operations.
Challenges:
Writing Loom programs would feel like weaving and unweaving a complex pattern of text. Debugging could involve tracing how threads interact and change in unexpected ways, just like trying to unravel a complicated weave.' |
Unified diff of changes made by edit (edit_diff) | '@@ -1,0 +1,49 @@
+Loom
+Concept:
+Loom is based on weaving strings of characters, and each "thread" (a string of characters) has its own significance. The language operates by manipulating these strings, weaving new ones, and unweaving them to produce results.
+
+Key Ideas:
+String as the Core Data Type:
+
+The primary datatype in Loom is a string of characters, which represents a "thread."
+Strings are manipulated by performing various "weaving" operations: adding, removing, or combining threads.
+Thread Operations:
+
+Weave: You combine two or more strings (threads) into a new string.
+Unweave: You separate a string into parts, either by position or pattern matching.
+Cut: You remove a portion of the string, essentially "cutting" a thread at a specific location.
+Twist: Change the character order of a string by shifting it around (like a rotation).
+Knot: Tie two strings together, making them dependent on each other. The strings interact in the same order, and modifying one can affect the other.
+Commands:
+
+weave a b: Combine the strings a and b into a new string.
+unweave a n: Break down string a into n parts.
+cut a n: Remove the n-th character from string a.
+twist a: Rotate string a by one position (a "shift" operation).
+knot a b: Link strings a and b together in a dynamic, dependent relationship.
+Memory Representation:
+
+The strings (threads) are stored in a "loom" (an array-like structure).
+Operations modify the loom's state. These states can be logged and viewed as the program executes, much like the changing pattern of a woven cloth.
+Output:
+
+The output of the program is the final form of a string (or series of strings) after all weaving operations are done.
+If the program successfully weaves a specific pattern or structure, it outputs it; otherwise, it indicates failure to achieve the pattern.
+
+Example Code:
+weave "Hello" "World"
+twist "HelloWorld"
+cut "HelloWorld" 5
+knot "Hello" "World"
+
+Example Explanation:
+First, the program combines "Hello" and "World" into a new string.
+Then, the string is twisted (rotated one character).
+The program cuts the string at the 5th position, splitting "HelloWorld" into two parts.
+Lastly, "Hello" and "World" are knotted together, which means they are now linked in a dynamic way—modifying one part might affect the other.
+Potential Use Cases:
+Creative text manipulation.
+Generating patterns and sequences.
+Creating puzzles or challenges where the goal is to achieve a specific string through a series of operations.
+Challenges:
+Writing Loom programs would feel like weaving and unweaving a complex pattern of text. Debugging could involve tracing how threads interact and change in unexpected ways, just like trying to unravel a complicated weave.
' |
New page size (new_size) | 2693 |
Old page size (old_size) | 0 |
Lines added in edit (added_lines) | [
0 => 'Loom',
1 => 'Concept:',
2 => 'Loom is based on weaving strings of characters, and each "thread" (a string of characters) has its own significance. The language operates by manipulating these strings, weaving new ones, and unweaving them to produce results.',
3 => '',
4 => 'Key Ideas:',
5 => 'String as the Core Data Type:',
6 => '',
7 => 'The primary datatype in Loom is a string of characters, which represents a "thread."',
8 => 'Strings are manipulated by performing various "weaving" operations: adding, removing, or combining threads.',
9 => 'Thread Operations:',
10 => '',
11 => 'Weave: You combine two or more strings (threads) into a new string.',
12 => 'Unweave: You separate a string into parts, either by position or pattern matching.',
13 => 'Cut: You remove a portion of the string, essentially "cutting" a thread at a specific location.',
14 => 'Twist: Change the character order of a string by shifting it around (like a rotation).',
15 => 'Knot: Tie two strings together, making them dependent on each other. The strings interact in the same order, and modifying one can affect the other.',
16 => 'Commands:',
17 => '',
18 => 'weave a b: Combine the strings a and b into a new string.',
19 => 'unweave a n: Break down string a into n parts.',
20 => 'cut a n: Remove the n-th character from string a.',
21 => 'twist a: Rotate string a by one position (a "shift" operation).',
22 => 'knot a b: Link strings a and b together in a dynamic, dependent relationship.',
23 => 'Memory Representation:',
24 => '',
25 => 'The strings (threads) are stored in a "loom" (an array-like structure).',
26 => 'Operations modify the loom's state. These states can be logged and viewed as the program executes, much like the changing pattern of a woven cloth.',
27 => 'Output:',
28 => '',
29 => 'The output of the program is the final form of a string (or series of strings) after all weaving operations are done.',
30 => 'If the program successfully weaves a specific pattern or structure, it outputs it; otherwise, it indicates failure to achieve the pattern.',
31 => '',
32 => 'Example Code:',
33 => 'weave "Hello" "World"',
34 => 'twist "HelloWorld"',
35 => 'cut "HelloWorld" 5',
36 => 'knot "Hello" "World"',
37 => '',
38 => 'Example Explanation:',
39 => 'First, the program combines "Hello" and "World" into a new string.',
40 => 'Then, the string is twisted (rotated one character).',
41 => 'The program cuts the string at the 5th position, splitting "HelloWorld" into two parts.',
42 => 'Lastly, "Hello" and "World" are knotted together, which means they are now linked in a dynamic way—modifying one part might affect the other.',
43 => 'Potential Use Cases:',
44 => 'Creative text manipulation.',
45 => 'Generating patterns and sequences.',
46 => 'Creating puzzles or challenges where the goal is to achieve a specific string through a series of operations.',
47 => 'Challenges:',
48 => 'Writing Loom programs would feel like weaving and unweaving a complex pattern of text. Debugging could involve tracing how threads interact and change in unexpected ways, just like trying to unravel a complicated weave.'
] |
Unix timestamp of change (timestamp) | '1735646259' |