57
\$\begingroup\$

Write a program that will generate a "true" output iff the input matches the source code of the program, and which generates a "false" output iff the input does not match the source code of the program.

This problem can be described as being related to quines, as the program must be able to somehow compute its own source code in the process.

This is code golf: standard rules apply. Your program must not access any special files, such as the file of its own source code.

Edit: If you so choose, true/false can be replaced with True/False or 1/0.

Example

If the source code of your program is bhiofvewoibh46948732));:/)4, then here is what your program must do:

Input (Stdin)

bhiofvewoibh46948732));:/)4

Output (Stdout)

true

Input

(Anything other than your source code)

Output

false
\$\endgroup\$
  • 7
    \$\begingroup\$ Is the true/false output a strong requirement, or are variations (True/False, 1/0) acceptable as well? \$\endgroup\$ – Cristian Lupascu Apr 17 '13 at 14:54
  • \$\begingroup\$ Is it a problem if the program outputs a little more than true/false (if it keeps being unambiguous and ends with true/false) ? \$\endgroup\$ – Denys Séguret Apr 19 '13 at 11:31
  • 1
    \$\begingroup\$ Related: Interpret your lang, but not yourself? \$\endgroup\$ – Ilmari Karonen Jan 11 '14 at 5:28
  • 5
    \$\begingroup\$ So you mean a Narcissist program? \$\endgroup\$ – PyRulez Jul 15 '17 at 5:57

36 Answers 36

33
\$\begingroup\$

JavaScript : 26

function f(s){return s==f}

I don't know if a JavaScript file really qualifies as a "program".

\$\endgroup\$
19
\$\begingroup\$

JavaScript ES6, 9 characters

This is the only (golfy) way to do it in JS. ES6 just makes it take super less characters

Run this in latest Firefox's Web Console:

f=x=>f==x

Example usage:

f("check") // returns false
f("x=>f==x") // returns true
\$\endgroup\$
  • 1
    \$\begingroup\$ @phinotpi - Is my entry still eligible to be picked as an answer ? \$\endgroup\$ – Optimizer Sep 13 '14 at 22:51
  • 6
    \$\begingroup\$ It could be argued though that the source in this case is f=x=>f==x and not x=>f==x, while Denys Séguret's version does indeed check the whole source. \$\endgroup\$ – Hankrecords Jun 8 '17 at 12:35
  • \$\begingroup\$ @Hankrecords Let JavaScript decide that. f=x=>f==x function f() f.toSource() "x=>f==x" (basically evaluate the code in console and then evaluate f.toSource() in a browser that supports that method. \$\endgroup\$ – Optimizer Jul 15 '17 at 7:22
  • \$\begingroup\$ Aren't anonymous functions allowed (shorten your code to x=>f==x) EDIT: nevermind, f is referenced inside of the function \$\endgroup\$ – MilkyWay90 Mar 16 at 22:07
9
\$\begingroup\$

Haskell, 72 characters

main=interact$show.(==s++show s);s="main=interact$show.(==s++show s);s="

Note: there is no end-of-line character at the end of the script.

$ runhaskell Self.hs < Self.hs
True
\$\endgroup\$
8
\$\begingroup\$

GolfScript, 11 chars

{`".~"+=}.~

Without the =, this code would be a quine that generates its own source code as a string. The = makes it compare this string to its input and output 1 if they match and 0 if they don't. Note that the comparison is exact — in particular, a trailing newline at the end of the input will cause it to fail.

Explanation:

  • { } is a code block literal in GolfScript;
  • . duplicates this code block, and ~ executes the second copy (leaving the first on the stack);
  • ` stringifies the code block, and ".~"+ appends .~ to it;
  • finally, = compares the resulting string with the input (which is pushed on the stack as a string by the GolfScript interpreter before the program starts) and returns 1 if they match and 0 if they don't.
\$\endgroup\$
7
\$\begingroup\$

Perl, Infinity 41 38 Characters

$_=q(print<>eq"\$_=q($_);eval"|0);eval

Update: The program no longer ends with a newline, which means it will work correctly on multi-line files. You have to enter input from STDIN without hitting enter. On Windows I was only able to do this by reading from a file.

Original solution:

print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(...
\$\endgroup\$
  • 1
    \$\begingroup\$ Nicely done! . . . \$\endgroup\$ – mob Apr 19 '13 at 16:19
  • \$\begingroup\$ Fails for a file that begins with the code, e.g. (cat id.pl; echo foo)|perl id.pl \$\endgroup\$ – Geoff Reedy Apr 20 '13 at 5:27
  • \$\begingroup\$ @GeoffReedy, thanks; the program did not handle multi-line input before. It is corrected now. \$\endgroup\$ – user7486 Apr 20 '13 at 7:56
  • \$\begingroup\$ Darn, is this code bowling? \$\endgroup\$ – Matthew Roh Jul 26 '17 at 14:08
7
\$\begingroup\$

><>, 68 bytes

Fishes love eating fish poop. Now we know they can distinguish theirs from their friends'.

00v      0+1~$^?)0~\;n0\
  >:@@:@gi:0(?\:a=?/=?!/$1+
  0n;n*=f$=2~~/

You can try it online !

\$\endgroup\$
  • 1
    \$\begingroup\$ This outputs 1 for any prefix of the code as well \$\endgroup\$ – Jo King Sep 30 '18 at 3:12
  • \$\begingroup\$ @JoKing it was worst than just prefixes of the script, it accepted truncated lines too ! I've fixed it, but I'm disappointed it's not as generic as I wanted it to be, I had to check the reached cell at the end of the script to make sure the whole code was matched. It can certainly be improved, but I'm not sure I will bother. \$\endgroup\$ – Aaron Oct 3 '18 at 15:09
6
\$\begingroup\$

Python 2, 55

a='a=%r;print a%%a==raw_input()';print a%a==raw_input()

Tested:

a='a=%r;print a%%a==raw_input()';print a%a==raw_input() -> True

(anything else) -> False

\$\endgroup\$
  • 3
    \$\begingroup\$ Fails on any file that begins with the first line equal to a='a=%r;print a%%a==raw_input()';print a%a==raw_input(). \$\endgroup\$ – boothby Apr 17 '13 at 18:56
  • \$\begingroup\$ True, multi-line input is not supported. \$\endgroup\$ – flornquake Apr 17 '13 at 20:06
  • \$\begingroup\$ A trivial fix would be to replace raw_input() with __import__('sys').stdin.read(). \$\endgroup\$ – feersum Feb 5 '15 at 22:53
  • \$\begingroup\$ I am confused by the challenge wording ('cause I am not good with english grammar). Is this allowed? print raw_input()==open(__file__).read() ? It is only 40 bytes, uses your raw_input() approach, but reads it's code. \$\endgroup\$ – Simon Jan 29 '18 at 14:12
  • 1
    \$\begingroup\$ @Simon That is not allowed, it is one of the standard loopholes for challenges like this. And yes, this is what it means by Your program must not access any special files, such as the file of its own source code. \$\endgroup\$ – PunPun1000 Feb 23 '18 at 18:28
6
\$\begingroup\$

JavaScript ES6, 16 14 bytes

$=_=>_==`$=`+$

Minus two bytes thanks to Neil.

31 bytes if we must take input via prompt.

$=_=>prompt()==`$=${$};$()`;$()

38 bytes if we must output via alert.

$=_=>alert(prompt()==`$=${$};$()`);$()

This is the proper way to do it, as Optimizer's answer does not accept the entire source code.

\$\endgroup\$
  • 1
    \$\begingroup\$ Nice, although I would just write '$='+$. \$\endgroup\$ – Neil Apr 4 '16 at 22:53
  • \$\begingroup\$ Oh, true. @Neil \$\endgroup\$ – Conor O'Brien Apr 4 '16 at 22:55
  • 1
    \$\begingroup\$ I'm pretty sure you need the ending ;$() because the function call is part of the quine. This also means that you'll need to switch to prompt to account for input. \$\endgroup\$ – Mama Fun Roll Apr 5 '16 at 5:14
  • 1
    \$\begingroup\$ That's not the problem. The function call is necessary because it's a part of the quine. Allowing the user to call it as a function would ruin the quine. \$\endgroup\$ – Mama Fun Roll Apr 5 '16 at 13:32
  • 1
    \$\begingroup\$ try $=_=>prompt()==`$=${$};$()`;$() \$\endgroup\$ – Mama Fun Roll Apr 5 '16 at 16:28
5
\$\begingroup\$

Node.js : 54

function f(){console.log(f+'f()'==process.argv[2])}f()

You test it by saving it into a file f.js (the exact name has no importance) and using

node f.js "test"

(which outputs false) or

node f.js "$(< f.js)"

(which outputs true)

I also made a different version based on eval :

eval(f="console.log('eval(f='+JSON.stringify(f)+')'==process.argv[2])")

It's now at 72 chars, I'll try to shorten that when I have time.

\$\endgroup\$
  • 1
    \$\begingroup\$ @dan1111 Why ? It doesn't access any file. I was just pointing how to launch the program to people not used to node.js. It doesn't read the file. \$\endgroup\$ – Denys Séguret Apr 18 '13 at 6:49
  • 1
    \$\begingroup\$ All of the Javascript solutions take advantage of the fact that you can access your own source code in JS. That may not be technically "accessing the file of its own source code", but it accomplishes the exact same thing. I suppose your answer is legal, though, as the question didn't specifically forbid this. \$\endgroup\$ – user7486 Apr 19 '13 at 9:32
  • \$\begingroup\$ Well, you access the source of a function (only the body to be precise) which is part of the program. That's like using mixin() in D. But I don't think the two other JS answers, including one from me, really qualify as "programs", though. \$\endgroup\$ – Denys Séguret Apr 19 '13 at 9:36
  • \$\begingroup\$ @dystroy actually mixin in D is more like using eval than reading source \$\endgroup\$ – ratchet freak Apr 19 '13 at 9:51
  • \$\begingroup\$ @ratchetfreak yes, you're right. But I think your program uses a kind of toString of the enum value, right ? And any code using eval/mixin is about the same trick than using the source of the function. \$\endgroup\$ – Denys Séguret Apr 19 '13 at 9:54
5
\$\begingroup\$

Smalltalk (Pharo 2.0 dialect)

Implement this 41 chars method in String (ugly formatting for code-golf):

isItMe^self=thisContext method sourceCode

Then evaluate this in a Workspace (printIt the traditional Smalltalk way)
The input is not read from stdin, it's just a String to which we send the message (what else a program could be in Smalltalk?):

'isItMe^self=thisContext method sourceCode' isItMe.

But we are cheating, sourceCode reads some source file...
Here is a variant with 51 chars which does not:

isItMe
    ^ self = thisContext method decompileString

And test with:

'isItMe
    ^ self = thisContext method decompileString' isItMe

If a String in a Workspace is not considered a valid input, then let's see how to use some Dialog Box in 116 chars
Just evaluate this sentence:

(UIManager default request: 'type me') = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)

Since decompile format includes CR and TAB, we change that withSeparatorsCompacted.
Then we skip the first 7 chars are 'doIt ^ '

Finally a 105 chars variant using stdin, just interpret this sentence from command line, just to feel more mainstream:

Pharo -headless Pharo-2.0.image eval "FileStream stdin nextLine = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)"
\$\endgroup\$
4
\$\begingroup\$

flex - 312 chars

Q \"
N \n
S " "
B \\
P "Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');"
M "(.|{N})* putchar('0');"
%%
Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');
(.|{N})* putchar('0');

Can probably be made shorter, but it works with multi-line input (necessary since the source code is multiple lines) and even for inputs that contain the program as a substring. It seems many of the answers so far fail on one or both of these.

Compile command: flex id.l && gcc -lfl lex.yy.c

\$\endgroup\$
3
\$\begingroup\$

D (133 chars)

enum c=q{import std.stdio;import std.algorithm;void main(){auto i=readln();writeln(equal("auto c=q{"~c~"};mixin(c);",i));}};mixin(c);
\$\endgroup\$
3
\$\begingroup\$

JavaScript (V8), 35

function i(){alert(prompt()==i+[])}

call i() and it will prompt for input

\$\endgroup\$
  • \$\begingroup\$ The +[] should be optional as JS will auto-type-cast it \$\endgroup\$ – Downgoat Jan 18 '16 at 18:10
3
\$\begingroup\$

GolfScript - 26

":@;[34]@+2*=":@;[34]@+2*=

Inspired from http://esolangs.org/wiki/GolfScript#Examples

Another version:

"[34].@@;+2*="[34].@@;+2*=

Too bad that \ is both swap and escape...

\$\endgroup\$
3
\$\begingroup\$

Python 2, 47 bytes

_='_=%r;print _%%_==input()';print _%_==input()

A simple quine with the added check.

\$\endgroup\$
  • \$\begingroup\$ This doesn't work. print is a function is Python 3. You'd need to do print(_%%_==input())';print(_%_==input()) or change it to Python 2. \$\endgroup\$ – Mego Jul 22 '16 at 5:52
3
\$\begingroup\$

CJam, 12 bytes

{s"_~"+q=}_~

Try it online!

Explanation

This just uses the standard CJam quine framework.

{s"_~"+q=}    e# Push this block (function literal).
          _~  e# Copy and run it.

What the block does:

 s            e# Stringify the top element (this block itself).
  "_~"+       e# Append "_~". Now the source code is on the stack.
       q      e# Read the input.
        =     e# Check if it equals the source code.
\$\endgroup\$
  • \$\begingroup\$ This is exactly the solution I had ._. \$\endgroup\$ – Esolanging Fruit Mar 27 '18 at 7:45
2
\$\begingroup\$

Tcl, 111 chars

set c {set c {$c};puts [expr {[read stdin] eq [subst -noc \$c]}]};puts [expr {[read stdin] eq [subst -noc $c]}]
\$\endgroup\$
2
\$\begingroup\$

Perl, 52 char

$_='$/=$\;$_="\$_=\47$_\47;eval";print<>eq$_|0';eval
\$\endgroup\$
2
\$\begingroup\$

Python, 187 bytes

import sys;code="import sys;code=!X!;print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace(!X!,code,1))";print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace("X",code,1))

Careful not to add newline at the end. Someone with better Python-fu might be able to shorten it.

\$\endgroup\$
  • 2
    \$\begingroup\$ You can use C=chr to drop several bytes. Also, shorten the variable name code. \$\endgroup\$ – Zach Gates Sep 19 '15 at 3:06
  • 2
    \$\begingroup\$ Since nobody said it for over a year, Welcome to PPCG! \$\endgroup\$ – Erik the Outgolfer Oct 16 '16 at 14:41
2
\$\begingroup\$

Husk, 11 bytes

=hS+s"=hS+s

Try it online!

Explanation

The explanation uses ¨ to delimit strings (to avoid unreadable escaping):

     "=hS+s  -- string literal: ¨=hS+s¨
  S+         -- join itself with
    s        -- | itself "showed": ¨"=hS+s"¨
             -- : ¨=hS+s"=hS+s"¨
 h           -- init: ¨=hS+s"=hS+s¨
=            -- is the input equal?

By removing the function = you can verify that it will indeed only match the source itself.

\$\endgroup\$
2
\$\begingroup\$

><>, 24 bytes

'1rd3*i={*}50l3-?.~i)*n;

Try it online!

Wrapping string literal followed by checking whether the input is identical to the stack, with a final check that there is no more input.

\$\endgroup\$
2
\$\begingroup\$

Jelly, 10 bytes

“Ṿ;$⁼”Ṿ;$⁼

Try it online!

“Ṿ;$⁼”Ṿ;$⁼
“Ṿ;$⁼”      String literal: 'Ṿ;$⁼'
        $   Next two links act on the string literal
      Ṿ     Uneval: '“Ṿ;$⁼”'
       ;    Append string: '“Ṿ;$⁼”Ṿ;$⁼' (source code)
         ⁼  Is the string above equal to the input?
\$\endgroup\$
2
\$\begingroup\$

05AB1E, 15 bytes

0"D34çýQ"D34çýQ

Modifies the default 0"D34çý"D34çý by adding Q (check for equality with the implicit input)

Try it online.

Explanation:

0                # Push 0 to the stack
                 #  STACK: [0]
 "D34çýQ"        # Push the string 'D34çýQ' to the stack
                 #  STACK: [0, 'D34çýIå']
         D       # Duplicate this string
                 #  STACK: [0, 'D34çýIå', 'D34çýIå']
          34ç    # Push '"' to the stack
                 #  STACK: [0, 'D34çýIå', 'D34çýIå', '"']
             ý   # Join the stack by this '"' delimiter
                 #  STACK: ['0"D34çýIå"D34çýIå']
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)

Cool 15 bytes alternative provided by @Grimy:

187745012D27BJQ

Try it online.

Explanation:

187745012        # Push integer 187745012 
                 #  STACK: [187745012]
         D       # Duplicate it
                 #  STACK: [187745012, 187745012]
          27     # Push integer 27
                 #  STACK: [187745012, 187745012, 27]
            B    # Convert 187745012 to base-27
                 #  STACK: [187745012, "D27BJQ"]
             J   # Join the values on the stack together
                 #  STACK: ["187745012D27BJQ"]
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)
\$\endgroup\$
  • 3
    \$\begingroup\$ 187745012D27BJQ is a tie. \$\endgroup\$ – Grimy Jun 13 at 12:21
1
\$\begingroup\$

C - 186 176 characters

One liner:

 *a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}

With whitespace (note that this breaks the program):

*a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];
main() {
  sprintf(b,a,34,a,34);
  gets(c);
  putchar(strcmp(b,c)?'0':'1');
}
\$\endgroup\$
1
\$\begingroup\$

Python 2, 40 bytes

s="print's=%r;exec s'%s==input()";exec s

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Stax, 26 bytes

"34bLN26)s:f="34bLN26)s:f=

Run and debug it

\$\endgroup\$
1
\$\begingroup\$

q, 8 bytes

{x~.z.s}

Return boolean on input matching the self-referential .z.s

\$\endgroup\$
1
\$\begingroup\$

Runic, 11 bytes

"3X4+kSqi=@

Try it online!

TIO got updated and there's no longer an issue reading input (and no longer requires a trailing whitespace).

Explanation

>                 Implicit entry
 "                Begin reading as string
  3X4+kSqi=@      Pushed to the stack as a string, loop around
 "                End reading as string
  3X4+            Push 3*10 and 4 to the stack, add them together
      k           Convert to character (")
       S          Swap the top two items on the stack
        q         Concatenate. This leaves only "3X4+kSqi=@ on the stack
         i        Read input
          =       Compare using .Equals, push 1 if equal, else 0
           @      Print and terminate

JoKing's solution:

"'<~qi=@|

Explanation

  <              Entry
 '               Read character (loop around)
"                Push "
         |       Mirror
"                Begin reading string (loop around)
 '<~ri=@|        Push the string '<~qi=@| (loop around)
"                End reading string
 '<~             Push the character < and then discard it
    q            Concatenate, stack contains only "'<~qi=@|
      i          Read input
       =         Compare
        @        Print and terminate
\$\endgroup\$
  • 1
    \$\begingroup\$ 10 bytes \$\endgroup\$ – Jo King Sep 30 '18 at 6:37
  • \$\begingroup\$ @JoKing Very clever. \$\endgroup\$ – Draco18s Sep 30 '18 at 15:00
  • \$\begingroup\$ Actually, 9 bytes avoids the reverse \$\endgroup\$ – Jo King Sep 30 '18 at 15:24
  • \$\begingroup\$ @JoKing I probably should've been able to arrive at that (from the 10 byte solution) myself, but I haven't had my cawfee yet. I'd already worked out yesterday that having the " on the left is the only place it can really go, because having it elsewhere complicates things. (But just now I had to run it in my debugger to see what it was doing...) \$\endgroup\$ – Draco18s Sep 30 '18 at 15:40
1
\$\begingroup\$

R, 54 bytes

f=function(s)s==paste0("f=function(s)s==", body(f)[3])

Try it online!

body gets the body of the function (splitting it a bit, so that body(f)[3] is everything from paste0 onwards). Interestingly, body reformats the code, adding spaces after commas, etc. This is thus a rare case of an R golf answer with a space after a comma.

This works because body(f) is an object of type language, and there exists an as.character method for this type. On the other hand, f and args(f) are of type closure, and cannot be converted to character type as far as I can tell. Please don't ask me what the language type is for…

\$\endgroup\$
0
\$\begingroup\$

PowerShell, 28 bytes

Very similar to this JavaScript answer, uses function provider.

filter f{"$Function:f"-eq$_}

Example

PS > '"$Function:f"-eq$_' | f
True

PS > 'xxx' | f
False
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.