একটি প্রোগ্রামিং ভাষায় একটি বৈশিষ্ট্য যুক্ত করুন [বন্ধ]


55

আপনার কাজটি হ'ল খুব চালাক লাইব্রেরি প্রয়োগ করে অথবা ইনপুট পাঠ্য প্রক্রিয়াকরণ করে এবং / অথবা সংকলন প্রক্রিয়াটি টুইঙ্ক করে প্রোগ্রামিং ভাষার একটি বৈশিষ্ট্য সম্পর্কে আলোচনা করা।

ধারনা:

  • সি (যেমন <?c printf("Hello,"); ?> world!) তে ইন্টারলিভিং পিএইচপি-স্টাইলের উপস্থাপনা যুক্ত করুন ।
  • একটি যোগ করুন নাল কোয়ালেসিং অপারেটর ঐ ভাষায় নয় C # এর এক।
  • পিএইচপি-তে ম্যাক্রোগুলি যুক্ত করুন।
  • gotoজাভাস্ক্রিপ্ট যোগ করুন ।
  • এক্স ভাষার সাথে প্যাটার্ন মেলা যুক্ত করুন
  • এমন একটি ভাষায় নামস্পেস সমর্থন যুক্ত করুন যা এটি নেই।
  • সি পিএইচপি এর মত চেহারা করুন।
  • হাস্কেলকে প্যাসকালের মতো দেখান।
  • ... (মন্তব্য বিভাগে মতামত পোস্ট করতে নির্দ্বিধায়)

নিয়মাবলী:

  • টেবিলে কিছু আনুন। হাস্কেলকে রূপক বৈশিষ্ট্য যুক্ত করতে কেবল "টেম্পলেট হাস্কেল" বলবেন না। এটি স্ট্যাকওভারফ্লো নয়।
  • পুরো বাস্তবায়নটি একটি স্ক্রিনফুলের সাথে ফিট করা উচিত (উদাহরণটি গণনা করছে না)।
  • এই কাজের জন্য বিশেষ করে কোনও বাহ্যিক সাইটে কোড হোস্ট করবেন না।
  • সবচেয়ে চিত্তাকর্ষক বা অবাক করা বৈশিষ্ট্যটি জিতেছে।

বৈশিষ্ট্যটি 100% সঠিকভাবে প্রয়োগ করার বিষয়ে চিন্তা করবেন না। অনেক দূরে! মূল চ্যালেঞ্জটি হ'ল আপনি কী করতে চান তা নির্ধারণ করা এবং আপনার পরিকল্পনামূলক উদ্যোগ গ্রহণযোগ্যতা না পাওয়া পর্যন্ত নিষ্ঠুর সাথে বিশদ বিবরণগুলি কেটে দেওয়া

উদাহরণ:

সি প্রোগ্রামিং ভাষায় একটি ল্যাম্বডা অপারেটর যুক্ত করুন ।

প্রাথমিক পদ্ধতি:

ঠিক আছে, আমি জানি আমি libgc ব্যবহার করতে চাই তাই আমার ল্যাম্বডাস উপরের এবং নীচের দিকে ফানার্গ সমস্যা সমাধান করবে। আমার ধারণা আমি প্রথমে সি প্রোগ্রামিং ভাষার জন্য পার্সার লিখি / খুঁজে পাই, তারপরে আমার সি এর টাইপ সিস্টেম সম্পর্কে সমস্ত শিখতে হবে। টাইপগুলি যতটা যায় তার কীভাবে তা বোঝাতে হয় তা আমাকে খুঁজে বের করতে হবে। আমার কি টাইপ অনুমান প্রয়োগ করতে হবে, বা আমার কেবল প্রয়োজন অনুসারে ফর্মাল প্যারামিটারটি টাইপ করা উচিত? সিআই-তে থাকা এই সমস্ত ক্রেজি বৈশিষ্ট্যগুলি কী সম্পর্কে এখনও জানেন না?

এটি পুরোপুরি স্পষ্ট যে সিতে ল্যাম্বডাকে সঠিকভাবে প্রয়োগ করা একটি বিশাল উদ্যোগ নেওয়া হবে। সঠিকতা সম্পর্কে ভুলে যাও! সরল করুন, সরল করুন।

উত্তম:

Wardর্ধ্বমুখী ফানার্গস স্ক্রু করুন, কার দরকার? আমি জিএনইউ সি এর নেস্টেড ফাংশন এবং বিবৃতি প্রকাশের সাথে কৌতুকপূর্ণ কিছু করতে সক্ষম হতে পারি । আমি টর্স, হ্যাকি কোড সহ সিটিতে একটি আশ্চর্যজনক সিনট্যাকটিক রূপান্তরটি প্রদর্শন করতে চেয়েছিলাম, তবে এর জন্য আমার এমনকি কোনও পার্সারের প্রয়োজন হবে না। যে অন্য একটি দিনের জন্য অপেক্ষা করতে পারেন।

ফলাফল (জিসিসি প্রয়োজন):

#include <stdio.h>
#include <stdlib.h>

#define lambda(d,e)({d;typeof(e)f(d){return(e);};f;})

#define map(F,A)({typeof(F)f=(F);typeof(*(A))*a=(A);({int i,l=((int*)(a))[-1]; \
typeof(f(*a))*r=(void*)((char*)malloc(sizeof(int)+l*sizeof(*r))+sizeof(int));  \
((int*)r)[-1]=l;for(i=0;i<l;i++)r[i]=f(a[i]);r;});})

#define convert_to(T) lambda(T x, x)
#define print(T, fmt) lambda(T x, printf(fmt "\n", x))

int main(void)
{
    int *array = 1 + (int[]){10, 1,2,3,4,5,6,7,8,9,10};
    map(print(int, "%d"), array);

    double *array2 = map(lambda(int x, (double)x * 0.5), array);
    map(print(double, "%.1f"), array2);

    long *array3 = map(convert_to(long), array2);
    map(print(long, "%ld"), array3);

    long product = 1;
    map(lambda(int x, product *= x), array);
    printf("product: %ld\n", product);

    return 0;
}

এটা সহজ ছিল, তাই না? এমনকি mapএটিকে দরকারী এবং সুন্দর করার জন্য আমি একটি ম্যাক্রোতে ফেলেছিলাম।


10
আমি মনে করি কেন থম্পসন আমাদের সকলকে বিট করেছেন : 0 বাইট কোডের।
dmckee

4
আমি একটি পূর্ণ উত্তর তৈরি করতে চাই না, তবে কেউ আগ্রহী হলে আমি জিএনইউ সিতে ক্লাস যুক্ত করেছি ।
রিচার্ড জে রস তৃতীয়

3
এটি যোগ্যতা অর্জন করে কিনা তা নিশ্চিত নই, তবে আমি সিটিতে ধারাবাহিকতার উদাহরণ লিখেছি । যদিও স্ক্রিনফুলের চেয়ে কিছুটা বেশি।
লুসার droog

1
যে কেউ এই প্রশ্নকে পুনরুত্থিত করেছে তার প্রতি আমার ধন্যবাদ; আমার জমা দেওয়ার জন্য আমার একটি দুর্দান্ত ধারণা আছে।
জোনাথন ভ্যান মাত্রে

2
সিতে একটি ল্যাম্বডা যুক্ত করুন ... আরে আমার দিকে তাকায় না।
লুশেনকো

উত্তর:


27

হাস্কেলের ওওপি সিনট্যাক্স

import Prelude hiding ((.))
a . b = b a

বস্তুর বৈশিষ্ট্য থাকতে পারে:

[1,5,3,2].length -- 4
[1,5,3,2].maximum -- 5
'a'.succ -- 'b'

... এবং পদ্ধতি:

"Hello world!".take(5) -- "Hello"
"Hello world!".splitAt(2) -- ("He","llo world!")
"Hello world!".map(toUpper) -- "HELLO WORLD!"

2
কোথাও আমি এই অপারেটরটিকে এর মতো লিখিত &এবং সংজ্ঞায়িত দেখেছি (&) = flip ($)
ফিটফাট

6
@ সুইশ আমি ব্যবহার করিনি &কারণ এটি 'অ্যাড্রেস অফ' ইউনিারি অপারেটর (হাস্কেলের পয়েন্টারগুলির বাস্তবায়ন পাঠকের জন্য অনুশীলন হিসাবে ছেড়ে গেছে)।
লর্টাব্যাক

1
@ সুইস আপনি ব্যবহার করে একটি চরিত্র (এবং একটি মস্তিষ্ক-চক্র) সংরক্ষণ করতে পারেনflip id
সান ডি

24

goto জাভাস্ক্রিপ্টে?

আমার প্রথম চিন্তাটি একটি কার্যকরী পন্থা ছিল - ফাংশনে একটি পরামিতি যুক্ত করার জন্য যেখানে মৃত্যুদন্ড কার্যকর হওয়া উচিত তা নির্দেশ করে একটি switchবিবৃতি এবং একটি বহিরাগত লুপের সাহায্যে বার বার তার নিজের ফেরতের মূল্যে ফাংশনটি কল করে । দুর্ভাগ্যক্রমে, এটি স্থানীয় ভেরিয়েবলগুলির ব্যবহারকে বাদ দেবে, কারণ তারা প্রতিটি গোটোর সাথে তাদের মান হারাবে।

আমি একটি withবিবৃতি ব্যবহার করতে এবং ফাংশনের শুরুতে সমস্ত পরিবর্তনশীল ঘোষণাগুলি সরিয়ে ফেলতে পারতাম , তবে আরও ভাল উপায় থাকতে হবে। অবশেষে এটি আমার কাছে জাভাস্ক্রিপ্টের ব্যতিক্রম হ্যান্ডলিং ব্যবহার করতে এসেছিল । আসলে, জোয়েল স্পলস্কি বলেছিলেন, "আমি ব্যতিক্রমগুলি" গোটো ... "এর চেয়ে ভাল বলে মনে করি না - সম্ভবত একটি নিখুঁত ফিট।

ধারণাটি ছিল কোনও ফাংশনের অভ্যন্তরে একটি অসীম লুপ স্থাপন করা, কেবলমাত্র একটি returnবিবৃতি বা অবিরত ব্যতিক্রম দ্বারা সমাপ্ত । ব্যতিক্রম হিসাবে বিবেচিত সমস্ত গোটো এর সমাপ্তি রোধ করতে লুপের মধ্যে ধরা পড়বে। এই পদ্ধতির ফলাফল এখানে:

function rewriteGoTo(func) {
    var code = '(';
    code += func.toString()
        .replace(/^\s*(\w+)\s*:/gm, 'case "$1":')
        .replace('{', '{ var $_label = ""; function goTo(label) { $_label = label; throw goTo; } while(true) try { { switch($_label) { case "": ');
    code += '} return; } catch($_e) { if($_e !== goTo) throw $_e; } })';
    return code;
}

আপনি এটি এর মতো ব্যবহার করতে পারেন - এমনকি ইএস 5 কড়া মোডে - ইন্টারনেট এক্সপ্লোরার ( ডেমো ) ব্যতীত:

var test = eval(rewriteGoTo(function(before) {
    var i = 1;
    again: print(before + i);
    i = i + 1;
    if(i <= 10) goTo('again');
}));

[ইন্টারনেট এক্সপ্লোরার, কোনও কারণে, বেনামি ফাংশনের কোডটি প্রকাশ করতে ব্যর্থ হয়, সুতরাং ফাংশনটির একটি নাম (পুনর্লিখনের আগে) দিতে হবে এবং সেই নামটি ব্যবহার করে এটি কল করতে হবে। অবশ্যই, এটি সম্ভবত কঠোর মোডের নিয়মগুলি ভঙ্গ করবে]]

এটি কোনও ব্লকের মধ্যে অবস্থিত একটি বিবৃতিতে লাফ দেওয়ার অনুমতি দেয় না (যতক্ষণ না ড্যাফের ডিভাইসের মতো নির্মাণগুলি আইনী হয়ে যায়), তবে আমরা এটি (অন্য, স্ব-সম্পাদনকারী পুনর্লিখনিত ফাংশন) এর সাথে ডিল করতে পারি, তাই না?


1
খুব সুন্দর! খুব সহজ কাজ এটি সহজ রাখা। ট্রিভিয়ার একটি আকর্ষণীয় বিট: যদি gotoজাভাস্ক্রিপ্টে পুরোপুরি প্রয়োগ করা হয় (যেখানে আপনি gotoকোনও সুযোগ, এমনকি কোনও ফাংশন ছাড়িয়ে যেতে পারেন তবে) এটি ধারাবাহিকতার জন্য সমর্থন জানায় for
জোয়ে অ্যাডামস

22

জাভাতে # নির্দিষ্ট

আমি ভেবেছিলাম জাভাতে ম্যাক্রোগুলি প্রয়োগ করা মজাদার হবে।

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * defines the use of #define. Usage:
 *
 * #def toReplaceCanHaveNoSpaces replacement can have extra spaces
 *
 * must be at the beginning of the line (excluding starting spaces or tabs)
 * 
 * @author Quincunx
 */
public class Define {

    public static void main(String[] args) {
        if (args.length != 1) {
            err("Please provide exactly 1 argument");
        }
        File source = new File(args[0]);
        if (!source.exists()) {
            err("Supplied filepath does not point to an existing file");
        }
        if (!getExtension(args[0]).equalsIgnoreCase(".java")) {
            err("Supplied file is not of type .java");
        }
        ArrayList<String> sourceData = new ArrayList<>();
        ArrayList<String[]> replacements = new ArrayList<>();
        try {
            BufferedReader read = new BufferedReader(new FileReader(source));
            String data;
            while ((data = read.readLine()) != null) {
                sourceData.add(data);
            }
            read.close();
        } catch (IOException ex) {
            Logger.getLogger(Define.class.getName()).log(Level.SEVERE, null, ex);
        }
        for (int index = 0; index < sourceData.size(); index++) {
            String line = sourceData.get(index);
            line = line.replaceAll("\t", "    ");
            for (String[] e : replacements) {
                line = line.replace(e[0], e[1]);
            }

            if (line.trim().charAt(0) != '#') {
                sourceData.set(index, line);
                continue;
            }
            while (line.charAt(0) != '#') {
                line = line.substring(1);
            }
            int indexOf = line.indexOf(" ");
            String type = line.substring(1, indexOf);

            switch (type) {
                case "def":
                case "define":
                    String toReplace = line.substring(indexOf + 1, line.indexOf(" ", indexOf + 1));
                    replacements.add(new String[]{toReplace, line.substring(line.indexOf(":") + 1)});
                    break;
                default:
                    err("The source code contains a # in which there is no correct type");
            }
        }

        try {
            BufferedWriter write = new BufferedWriter(new FileWriter(source));
            for (String s : sourceData) {
                write.write(s);
                write.newLine();
            }
            write.close();
        } catch (IOException ex) {
            Logger.getLogger(Define.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static void err(String message) {
        System.err.println(message);
        System.exit(1);
    }

    public static String getExtension(String filePath) {
        return filePath.substring(filePath.lastIndexOf("."));
    }

}

নমুনা ব্যবহার (পূর্বে পোস্ট করা কোডে রূপান্তর; আসুন এটি অদ্ভুত করুন):

#def @ o
#def ~ a
#def $ i
#def ` e
#d`f % m
#d`f ! {
#d`f & d
#&`f _ }
#&`f 2 (
#&`f 7 )
#&`f $%p@rt$@. $%p@rt j~v~.$@.
#&`f $%p@rtu. $%p@rt j~v~.ut$l.
#&`f ps publ$c st~t$c
#&`f Str Str$ng

$%p@rt$@.Buff`r`&R`~&`r;
$%p@rt$@.Buff`r`&Wr$t`r;
$%p@rt$@.F$l`;
$%p@rt$@.F$l`R`~&`r;
$%p@rt$@.F$l`Wr$t`r;
$%p@rt$@.IOExc`pt$@n;
$%p@rtu.Arr~yL$st;
$%p@rtu.l@gg$ng.L`v`l;
$%p@rtu.l@gg$ng.L@gg`r;

#d`f L$st Arr~yL$st
#d`f l@g; L@gg`r.g`tL@gg`r2D`f$n`.cl~ss.g`tN~m`277.l@g2L`v`l.SEVERE, null, `x7;    

publ$c cl~ss D`f$n` !

    ps v@$d %ain2Str[] ~rgs7!
        $f 2~rgs.l`ngth != 17 !
            `rr2"Pl`~s` pr@v$&` `x~ctly 1 ~rgu%`nt"7;
        _
        F$l` squrc` = n`w F$l`2~rgs[0]7;
        $f 2!sourc`.`x$sts277 !
            `rr2"Suppli`& f$l`p~th &@`s n@t p@int t@ ~n `x$st$ng f$l`"7;
        _
        $f 2!g`tExt`ns$@n2~rgs[0]7.`qu~lsIgn@r`C~s`2".j~v~"77 !
            `rr2"Suppl$`& f$l` $s n@t @f typ` .j~v~"7;
        _
        L$st<Str> s@urceDat~ = n`w List<>27;
        L$st<Str[]> repl~cem`nts = n`w L$st<>27;
        try !
            Buff`r`&R`a&`r r`a& = new Buff`redRe~&`r2n`w F$l`R`~&`r2s@urc`77;
            Str &~t~;
            wh$l` 22&~t~ = r`~&.r`~&L$n`277 != null7 !
                s@urc`D~t~.~&&2&ata7;
            _
            re~&.cl@se27;
        _ c~tch 2IOExc`ption ex7 !
            log;
        _
        f@r 2$nt $n&`x = 0; $ndex < s@urc`D~t~.s$z`27; $nd`x++7 !
            Str l$n` = s@urc`D~ta.get2index7;
            line = line.r`pl~c`All2"\t", "    "7;
            for 2Str[] ` : r`pl~c`%`nts7 {
                line = line.r`pl~c`2`[0], e[1]7;
            _

            if 2l$ne.tr$%27.ch~rAt207 != '#'7 !
                sourc`D~t~.s`t2$n&`x, l$n`7;
                c@nt$nu`;
            _
            wh$l` 2line.ch~rAt207 != '#'7 !
                l$ne = l$ne.substr$ng217;
            _
            $nt in&`xOf = line.$n&`xOf2" "7;
            Str typ` = line.substring21, indexOf7;

            sw$tch 2type7 !
                c~s` "&`f":
                c~s` "def$n`":
                    str t@R`pl~c` = line.substring2indexOf + 1, line.indexOf2" ", indexOf + 177;
                    r`pl~c`%`nts.~&&2n`w s\Str[]!t@R`place, line.substring2line.indexOf2":"7 + 17_7;
                    br`~k;
                def~ult:
                    err2"Th` s@urc` c@&` c@nt~$ns ~ # $n wh$ch th`r` i$s n@ c@rr`ct typ`"7;
            _
        _

        try !
            Buff`r`&Wr$ter wr$te = new BufferedWriter2new F$l1Wr$t1r2s@urc177;
            for 2Str s : s@urceData7 !
                wr$te.write2s7;
                wr$te.n`wLin`27;
            _
            wr$t`.cl@s`27;
        _ c~tch 2IOExc`pt$@n `x7 !
            l@g;
        _
    _

    ps v@$& `rr2Str m`ss~g`7 !
        Syst`%.`rr.pr$ntln2message7;
        Syst`%.`x$t217;
    _

    ps Str g`tExt`nsi@n2Str fileP~th7 !
        r`turn f$lePath.substr$ng2f$l`P~th.l~stInd`xOf2"."77;
    _

_

7
আমি দ্বিতীয় ব্লকটি দিয়ে স্ক্রোল করছিলাম এবং আমার একমাত্র চিন্তা ছিল "... খরগোশের গর্তের নিচে"।
সোহম চৌধুরী

18

সি মধ্যে পূর্বাভাস

ইটারেট অ্যারে (পয়েন্টারের মাধ্যমে প্রাপ্ত স্ট্যাটিক অ্যারেগুলির জন্য কাজ করে)

//syntactic beauty
#define in ,    

//syntactic beauty's helper macro
#define foreach(a) _foreach(a)

//the real foreach macro
#define _foreach(e,arr)\
typeof (&arr[0]) e;\
for (e=&arr[0];e!=&arr[sizeof(arr)/sizeof(arr[0])];e++)

এটি পরীক্ষা করার জন্য:

int int_arr[3]={10,20,30};    
char *strings[]={"Hello","World","Foreach","Test"};

foreach (num in int_arr) {
        printf ("num=%d\n",*num);
}

foreach (str in strings) {
        printf ("str=%s\n",*str);
}

ফলাফল:

num=10
num=20
num=30
str=Hello
str=World
str=Foreach
str=Test

17

গ মধ্যে সম্পত্তি

টমাসজ ওয়েগ্রজানভস্কি সম্পত্তিটি অ্যাক্সেস করা অবস্থায় ইচ্ছাকৃতভাবে প্রোগ্রামটি সেগফোল্ট করে প্লেন সিতে সম্পত্তিগুলি প্রয়োগ করেছিলেন implemented

structএকাধিক পৃষ্ঠাগুলি অতিক্রম করে এমন একটি তৈরি করে "সম্পত্তি" যুক্ত একটি বস্তু সেট আপ করা হয় , যাতে সম্পত্তিটির মেমরির ঠিকানা প্রকৃত ডেটা সদস্যদের থেকে পৃথক পৃষ্ঠায় থাকে তা নিশ্চিত করে। সম্পত্তিটির পৃষ্ঠাটি অ্যাক্সেস হিসাবে চিহ্নিত করা হয়েছে, গ্যারান্টি দিয়ে যে সম্পত্তিটি অ্যাক্সেস করার চেষ্টা করা সেগফাল্টের কারণ হবে। ফল্ট হ্যান্ডলার পরে চিহ্নিত করে যে কোন সম্পত্তির অ্যাক্সেসটি সেগফল্টের কারণ হয়েছিল এবং সম্পত্তিটির মান গণনা করার জন্য উপযুক্ত ফাংশনটি কল করে, যা সম্পত্তির মেমরির ঠিকানায় সঞ্চিত হয়।

ফল্ট হ্যান্ডলারটি গণ্যমানের মানটি সুসংগত রাখার জন্য ডেটা পৃষ্ঠাটিকে কেবল পঠনযোগ্য হিসাবে চিহ্নিত করে; এরপরে আপনি যখন কোনও ডেটা সদস্যকে লেখার চেষ্টা করবেন, যা সেগফোল্টকে ট্রিগার করে, যার হ্যান্ডলার ডেটা পৃষ্ঠাটিকে পঠন-লিখন এবং সম্পত্তি পৃষ্ঠাটি অ্যাক্সেস হিসাবে সেট করে (নির্দেশ করে যে এটি পুনরায় সংশোধন করা দরকার)।


15

কমন লিস্পে গণনা করা

আমি প্রাথমিকভাবে আসি থেকে বাস্তবায়ন করেছি। তবে এটি যথেষ্ট ভাল ছিল না।

গণিত গোটো দ্বারা অনুপ্রাণিত হয়ে আমি গণিত আগমনটি বাস্তবায়নের সিদ্ধান্ত নিয়েছি।

(defmacro computed-come-from-tagbody (&rest statements)
  (let ((has-comp-come-from nil)
        (comp-come-from-var nil)
        (start-tag (gensym))
        (end-tag (gensym)))

    (let ((current-tag start-tag)
          (come-froms (make-hash-table :test #'eq)))

      (let ((clauses '()))
        (loop for statement in statements do
             (if (symbolp statement)
                 (setf current-tag statement))

             (cond
               ((and (consp statement)
                     (eql 'come-from (car statement)))

                (setf has-comp-come-from t)
                (setf (gethash (cadr statement) come-froms) current-tag))
               (t (push statement clauses))))


        (if (not has-comp-come-from)
            `(tagbody ,@(reverse clauses))
            (let ((res '())
                  (current-tag start-tag))
              (loop for clause in (reverse clauses) do
                   (cond
                     ((symbolp clause)
                      (push clause res)
                      (setf current-tag clause)
                      ;; check all vars for jumps
                      (push
                       `(progn ,@(loop for k being the hash-key of come-froms
                                    for v being the hash-value of come-froms collect
                                      `(when (eql ,k ,current-tag)
                                         (go ,v))))
                       res))
                     (t (push clause res))))
              `(macrolet ((come-from (idx)
                            (declare (ignore idx))
                            (error "Come-from cannot be used with another form.")))
                 (tagbody ,@(reverse res)))))))))

ব্যবহারের উদাহরণ

(come-from x) ; whenever we're at the top of a labeled block and the value of x is equal to the label, jump back to this point.

ট্যাগবডি-তে প্রতিটি আগত ঘোষণাপত্রের জন্য, আগত ভেরিয়েবলটি বর্তমান লেবেলের সমান কিনা তা প্রতিটি লেবেলে তা পরীক্ষা করে দেখবে এবং যদি তা হয় তবে সংশ্লিষ্ট প্রত্যাবর্তন-সংক্রান্ত ঘোষণায় ঝাঁপ দাও।

অভিবাদনের

(let ((x :repeat)
      (y :exit))
   (computed-come-from-tagbody
      :loop              ;; when x == :loop jump to :loop.  when y == :loop jump to :exit
      (come-from x)
      (format t "What is your name? ")
      (let ((name (read-line)))
         (terpri)
         (format t "Hello ~a~%" name)
         (print (string= name "exit"))
         (when (string= name "exit")
             (setf x nil
                   y :repeat)))
       :repeat           ;; when x = :repeat jump to loop, when y = :repeat jump to exit
       :exit             ;; when x = :exit jump to loop, when y = :exit jump to exit
       (come-from y)))

FizzBuzz

(let ((i 0)
      (x nil)
      (y nil))
   (computed-come-from-tagbody
       :loop
       (come-from x)
       (cond
         ((> i 100)  (setf x nil
                           y :end-iteration)) 
         (t (or (and (zerop (mod i 3)) (zerop (mod i 5)) (print "FizzBuzz"))
                (and (zerop (mod i 3)) (print "Fizz"))
                (and (zerop (mod i 5)) (print "Buzz"))
                (print i))  
            (incf i)
            (setf x :end-iteration)))
       :end-iteration
       :end
       (come-from y)
       (print "done")))


13

পিএইচপি-তে ম্যাক্রোগুলি যুক্ত করুন

আমরা এই কাজের জন্য কেবল সি প্রিপ্রসেসর ব্যবহার করতে পারি।

একটি পিএইচপি স্ক্রিপ্ট:

<?php

#define ERROR(str) trigger_error(#str, E_USER_ERROR)

function test() {
        ERROR(Oops);
}

এটি পাইপ যদিও সিপিপি:

cpp < test.php

ফলাফল:

<?php

function test() {
 trigger_error("Oops", E_USER_ERROR);
}

এমন কি পিএইচপি বৈশিষ্ট্যগুলির সাথে বিরতি দেবে না যা সি তে বিদ্যমান নেই? যেমন হেরডোকস। আফায়ার সি পি পি'র ব্যাকরণের সাথে বেশ শক্তভাবে আবদ্ধ ছিল।
জোয়

1
আমি মনে করি প্রিপ্রোসেসর কেবল এটি বোঝার চেষ্টা না করে ইনপুটটি লেকসেস করে। একটি <<<HEREDOCহ'ল 3-এর চেয়ে কম বা বাম-শিফট এবং শনাক্তকরণকারী :-) এটি হেরডোক স্ট্রিংগুলিতে ম্যাক্রো-প্রতিস্থাপনটি করবে do
আর্নাড লে ব্ল্যাঙ্ক

সি প্রিপ্রসেসর আউটপুটটিতে অতিরিক্ত আবর্জনা যুক্ত করে, সুতরাং আপনার উদাহরণটি প্রত্যাশার মতো কাজ করবে না
বেনাম কাপুরুষ 13

1
একটি grep -v ^#পুরোপুরি ঠিক। আমার ধারণা এই প্রশ্নের জন্য এটি যথেষ্ট :-)
আর্নাড লে ব্ল্যাঙ্ক

10

পাইথনে প্যাটার্ন ম্যাচিং গার্ডস

def pattern_match(n, s="__fns"):
 s=n+s;g=globals()
 def m(f):
  def a(*r):
   for f in g[s]:
    if reduce(lambda c,t:c and eval(t[1:],{},dict(zip(f.func_code.co_varnames,r))),filter(lambda x:x and x[0]is"|",map(lambda x:x.strip(),f.func_doc.split("\n")))): return f(*r)
  g[n]=a;g[s]=(g.get(s)or[])+[f]
  return a
 return m

ফাংশনটির বডিটি 288 টি অক্ষরে আসে।

প্যাটার্ন ম্যাচিং গার্ডস আপনাকে যুক্তির মানগুলির উপর নির্ভর করে সম্পূর্ণ আলাদা ফাংশন ব্যবহার করার অনুমতি দেয়। যদিও এটি সহজেই ifবিবৃতিগুলির একটি সিরিজ দিয়ে অনুকরণ করা যায় , প্যাটার্ন মেলানো গার্ডরা কোডের পৃথক বিভাগগুলিতে সহায়তা করতে পারে এবং কিছু ক্রেজি রূপক তৈরি করার জন্য এটি দুর্দান্ত অজুহাত।

pattern_matchএকটি সাজসজ্জা যা একটি নতুন ফাংশন তৈরি করে যা প্যাটার্ন মেলানো গার্ডদের প্রয়োগ করে । পাইপ ( |) দিয়ে শুরু হওয়া লাইনে প্রতিটি ডক্ট্রাস্টিংয়ে দেওয়া প্রতিটি "সাব-ফাংশন" এর শর্তাদি । যদি সমস্ত শর্ত সত্যতার সাথে মূল্যায়ন করে তবে ফাংশনের সেই সংস্করণটি চালিত হবে। কোনও ম্যাচ না পাওয়া পর্যন্ত ক্রিয়াকলাপগুলি পরীক্ষা করা হয়। অন্যথায়, Noneফেরত দেওয়া হয়।

একটি উদাহরণ স্পষ্ট করতে সাহায্য করবে:

@pattern_match("test1")
def test1_a(a, b, c):
    """
    This guard tests if a and c are positive

    | a > 0
    | c > 0
    """
    return a + b + c

@pattern_match("test1")
def test1_b(a, b, c):
    """
    This pattern only ensures b is positive

    | b > 0
    """
    return b + c

@pattern_match("test1")
def test1_c(a, b, c):
    """
    Final catchall

    | True
    """
    return 0


print test1(1,2,3) # (a) >>> 6
print test1(1,2,0) # (b) >>> 2
print test1(1,0,0) # (c) >>> 0
print test1(0,0,1) # (b) >>> 1

হাসকেলে এটিকে রক্ষক বলা হয় , প্যাটার্ন ম্যাচিং নয়। হাস্কেলে, প্যাটার্ন f [a,b,c] = ...মিলটি আপনাকে বলতে দেয় , যা কেবল কোনও শিকারীর বিরুদ্ধে তর্কটি পরীক্ষা করে না, তবে সফল ম্যাচের পরে এটি সম্পর্কিত ভেরিয়েবলগুলিকে আবদ্ধ করে। যদিও এটি এখনও বেশ দুর্দান্ত।
জোয় অ্যাডামস

ডি Oy! যে সংশোধন করার জন্য ধন্যবাদ! আমি হাস্কেল সম্পর্কেও ভাবছিলাম, বিশেষত দুটি পৃথক পূর্বাভাস (অর্থাত্ ) f (x:xs) = ...এবং একটি ফাংশন সংজ্ঞায়িত করার দিকে মনোনিবেশ করছিলাম f [] = ...। কোনওরকমভাবে আমি সেখানে প্রহরীদের বিভ্রান্ত করেছি, কিন্তু আমি সেখান |থেকে নিয়েছিলাম ।
জ্যাবঙ্কস

এটি কোনও কোড গল্ফ চ্যালেঞ্জ নয়; আপনি চাইলে আরও ভার্বোজ (এবং পঠনযোগ্য) হতে পারেন! :)
রেইচার্স


7

লুয়ায় কাস্টম অপারেটররা

কাস্টম ইনফিক্স অপারেটরগুলি সংজ্ঞায়িত করার জন্য পোগগুলি লুয়ায় চালকভাবে অপারেটর ওভারলোডিংকে অপব্যবহার করে । অপারেটর বিভাগকরণ (আংশিকভাবে অপারেটর দিয়ে অপারেটর প্রয়োগ করা) এবং ফলস্বরূপ অবজেক্টটিকে কল করে যেমন এটি কোনও ফাংশন হিসাবে সমর্থন করে আমি এটিকে প্রসারিত করেছি।

---- implementation
function infix(f)
  local function g(self, x)
    return f(self[1] or x, self[2] or x)
  end

  local mt   = { __sub = g, __call = g }
  local self = {}
  return setmetatable(self,
           { __sub = function (lhs,rhs)
                       return rhs == self and setmetatable({ lhs, nil }, mt)
                                           or setmetatable({ nil, rhs }, mt)
                     end })
end

---- testing
local eq   = infix(function (a, b) return a == b end)
local ge   = infix(function (a, b) return a >= b end)

local comp = infix(function (a, b) return a < b and -1
                                       or a > b and  1
                                       or            0 end)

function filter(pred, xs)
  local res = {}
  for i=1,#xs do
    if pred(xs[i]) then table.insert(res, xs[i]) end
  end
  return res
end

print(1  -eq-  1)                                      --> true
print(1 -comp- 0)                                      --> 1
print((4 -ge)(1))                                      --> true
print(table.unpack(filter(ge- 0, {1,-4,3,2,-8,0})))    --> 1   3   2   0

7

জাভাস্ক্রিপ্টে একাধিক স্ট্রিং

মাল্টলাইন স্ট্রিংয়ের জন্য এই বিস্তৃত সিনট্যাক্সে, প্রতিটি মাল্টলাইন স্ট্রিং এর আগে (function(){/*এবং একটি নতুন লাইন থাকবে এবং তার পরে একটি নতুন লাইন এবং */}+'').split('\n').slice(1,-1).join('\n')

এই আশ্চর্যজনক, স্বজ্ঞাত সিন্ট্যাক্স ব্যবহার করে, আমরা শেষ পর্যন্ত বহু লাইন স্ট্রিং ব্যবহার করতে পারি:

var string = (function(){/*
THIS IS A MULTILINE STRING
HOORAY!!!
*/}+'').split('\n').slice(1,-1).join('\n');

console.log(string) // THIS IS A MULTILINE STRING
                    // HOORAY!!!

আমাদের সাধারণ বাক্য গঠনটি পছন্দ না করে এমন লোকদের জন্য আমাদের কল্পিত নতুন ভাষার সংকলক রয়েছে:

function compile(code)
{
    return code.replace("#{", "(function(){/*").replace("}#", "*/}+'').split('\n').slice(1,-1).join('\n')")
}

সংকলিত-ভাষা সংস্করণে একই উদাহরণ:

var string = #{
THIS IS A MULTILINE STRING
HOORAY!!!
}#;
console.log(string) // THIS IS A MULTILINE STRING
                    // HOORAY!!!

1
কিছু কারণে আমি */আমার মাল্টলাইন স্ট্রিংগুলি রাখতে পারি না । স্ট্রিংগুলিতে রিজেক্সস অন্তর্ভুক্ত করার সময় এটি অত্যন্ত বিরক্তিকর!
ফায়ারফ্লাই

@ ফায়ারফ্লাই আসলে আমার মনে হয় এটি এখনও কার্যকর হয় this সিনটেক্স হাইলাইটিং যদিও অদ্ভুত হয়ে যায়।
গর্বিত হাসেল্লার

6

সি # তে স্লাইজেবল তালিকা (পাইথনের মতো)

আমি সবসময় পাইথনের স্লাইস স্বরলিপি উপভোগ করেছি এবং আশা করি এটি সি # তে পাওয়া যায় wish

ব্যবহার:

SliceList<int> list = new SliceList<int>() { 5, 6, 2, 3, 1, 6 };
var a = list["-1"];     // Grab the last element (6)
var b = list["-2:"];    // Grab the last two elements (1,6)
var c = list[":-2"];    // Grab all but the last two elements (5,6,2,3)
var d = list["::-1"];   // Reverse the list (6,1,3,2,6,5)
var e = list["::2"];    // Grab every second item (5,2,1)

কোড, ত্রুটি প্রমাণ থেকে দূরে:

public class SliceList<T> : List<T>
{
    public object this[string slice]
    {
        get
        {
            if (string.IsNullOrWhiteSpace(slice))
                return this.ToList();
            int[] values = { 0, Count, 1 };
            string[] data = slice.Split(':');
            for(int i = 0; i < data.Length; i++)
            {
                if (string.IsNullOrEmpty(data[i])) continue;
                int value;
                int.TryParse(data[i], out value);
                if(value < 0 && i < 2)
                    value += Count;
                values[i] = value;
            }
            if (data.Length == 1)
                return this[values[0]];
            int start = Math.Min(values[0], values[1]);
            int stop = Math.Max(values[0], values[1]);
            int step = values[2];
            int sign = Math.Sign(step);
            if (sign < 0)
            {
                var temp = start;
                start = stop-1;
                stop = temp-1;
            }

            SliceList<T> newList = new SliceList<T>();
            for (int i = start; i != stop; i += step)
                newList.Add(this[i]);

            return newList;
        }
    }
}

নেট থেকে অন্তর্ভুক্ত করার জন্য আমি দীর্ঘদিন আগে টুকরো টুকরো করার অনুরোধ করেছি, এটি এখনও সহজভাবে উপেক্ষা করা হয়েছে :(
রে

6

সি সহজ করুন

এই কোডটি আপনাকে সি প্রোগ্রাম লিখতে দেয় যা ধরণের স্ক্রিপ্টিং ভাষার সাথে আরও কিছুটা সাদৃশ্যপূর্ণ। এটিতে 'ভার', 'ইজ', 'স্ট্রিং', 'প্লাস', 'সমান' এবং বেশ কয়েকটি অন্যান্য কীওয়ার্ড রয়েছে। এটি প্রচুর সংজ্ঞায়িত বিবৃতি দিয়ে কাজ করে ।

// pretty.c

#include<stdio.h>

#define function int
#define var int
#define is =
#define then {
#define do {
#define does {
#define end }
#define equal ==
#define notequal !=
#define greater >
#define less <
#define greaterequal >=
#define lessequal <=
#define display printf
#define otherwise }else{
#define increase ++
#define decrease --
#define plus +
#define minus -
#define times *
#define divide /
#define character char
#define string char*
#define integer int

এটি আপনাকে কোড লিখতে দেয়:

/*
Preprocessor abuse, Yay!
*/

#include "pretty.c"

function main() does
    var myVar is 1;
    if(myVar greater 2)then
        display("Yep\n");
    otherwise
        display("Nope\n");
    end

    for(var i is 0; i less 10; i increase)do
        display("Loop: %d\n", i);
    end

    string myString = "Hello";
    display(myString);
end

উপরেরটি এতে প্রসারিত হয়:

int main() {
    int myVar = 1;
    if(myVar > 2){
        printf("Yep\n");
    }else{
        printf("Nope\n");
    }

    for(int i = 0; i < 10; i ++){
        printf("Loop: %d\n", i);
    }

    char* myString = "Hello";
    printf(myString);
}

সম্ভবত অত্যধিক দরকারী নয় তবে আমি এটি বেশ আকর্ষণীয় বলে মনে করেছি যে আপনি মূলত একটি গোছা গোষ্ঠীর মাধ্যমে একটি সম্পূর্ণ প্রোগ্রামিং ভাষা তৈরি করতে পারেন #define


এটি জাভাস্ক্রিপ্ট / রুবি ম্যাসআপের মতো দেখাচ্ছে ...
বিটা ডিকায়

এর যথেষ্ট কোনও উচ্চতর সীমা নেই - জটিল পর্যাপ্ত #defineপরিমাণের সাহায্যে আপনি এমনকি মৌলিক সি স্তরটি নীচে রাখার পরেও আপনার ভাষার জিনিসগুলি ব্যতিক্রম হ্যান্ডলিং এবং আবর্জনা সংগ্রহের মতো দিতে পারেন ।
লুশেনকো

5

TCL

টিসিএল এর নেই do ... whileবা আছে do ... until...

proc do {body op expr} {
    uplevel 1 $body
    switch -exact -- $op {
        while {
            while {[uplevel 1 [list expr $expr]} {
                uplevel 1 $body
            }
        }
        until {
            while {![uplevel 1 [list expr $expr]} {
                 uplevel 1 $body
            }
        }
    }
}

উদাহরণ:

do {
    puts -nonewline "Are you sure? "
    flush stdout
    set result [gets stdin]
} while {[string is boolean -strict $result]}

uplevel কলকারীদের স্কোপে একটি স্ক্রিপ্ট কার্যকর করে।


5

পোস্টস্ক্রিপ্টে যান

আমার প্রথম ধারণাটি ছিল যে আমাকে এক্সিকিউট স্ট্যাকের সাথে বিদ্রূপ করতে হবে, সুতরাং এই ভুয়া শুরুটি ভূতলিপি (বা এক্সপোস্ট) থেকে থামার জন্য ধারাবাহিকতা অপারেটরটিকে খনন করে।

/_stopped_mark
{countexecstack array execstack dup length 2 sub get}
stopped pop def 

তবে, এটি এর চেয়ে সহজ। ফাইল হ্যান্ডেলের সমস্ত সদৃশগুলির জন্য ফাইল-অবস্থানটি সমান (কারণ setfilepositionএটির যুক্তিটি গ্রাস করে, সুতরাং এই ফাংশনটির জন্য এটি কেবলমাত্র কার্যকর শব্দার্থক)।

/LABELS 10 dict def 

/: { % n :  define label
    LABELS exch currentfile fileposition put 
} def 

/goto { % goto label
    currentfile exch LABELS exch get setfileposition
} def 

/x 0 def 

/here :
    /x x 1 add def 

    x 5 ne {
        /here goto
    } if

x =

এটা তোলে ছাপে 5

উপরোক্ত কিছু সীমাবদ্ধতা আছে। লাফটি তাত্ক্ষণিকভাবে নয়, তবে ঘটে যখন আইডি-বডিটি শীর্ষ-স্তরের দিকে ফিরে আসে এবং দোভাষী যদি আবার ফাইল থেকে পড়তে থাকেন (যদি অ্যারে থেকে পড়ার পরিবর্তে যদি-বডি থাকে)। এই মুহুর্তে, ফাইলটি পুনঃস্থাপন করা হয়েছে এবং 'গোটো' কার্যকর হয়।


এবং এটি একটি অভিধানে কেবল সংজ্ঞা, যাতে আপনি লেবেলগুলির জন্য প্রায় কোনও প্রকারের ব্যবহার করতে পারেন।
লুসার droog

আপনি ফাইলের শুরু থেকে বাইট গণনা করে নিখুঁত জাম্পগুলিও করতে পারেন currentfile <pos> setfileposition
লুসার droog

4

Symbol#to_proc রুবিতে যুক্তি সহ

Symbol#to_procসত্যিই সংক্ষেপে রুবি কোডটি লেখার জন্য আমার প্রিয় কৌশলগুলির মধ্যে একটি। ধরুন আপনার আছে

nums = [1, 2, 3, 4]
text = %w(this is a test)

এবং আপনি যথাক্রমে ভাসমান এবং বড় হাতের শব্দের সামগ্রী numsএবং রূপান্তর করতে চান textSymbol#to_procআপনাকে এই জাতীয় কোডটি ছোট করার অনুমতি দেয়:

nums.map { |num| num.to_f }
text.map { |word| word.upcase }

এটি:

nums.map(&:to_f)
text.map(&:upcase)

অসাধারণ! কিন্তু আমরা কি প্রতিটি উপাদান বাড়াতে চান তাহলে numsকরতে iতম ক্ষমতা, বা প্রতিটি সংঘটন প্রতিস্থাপন sসঙ্গে *মধ্যে text? কোডটি ছোট করার কোনও উপায় আছে কি?

nums.map { |num| num ** 1i }
nums.map { |word| word.gsub('s', '*') }

হায়, ব্যবহার করার সময় তর্কগুলি পাস করার কোনও সহজ উপায় নেই Symbol#to_proc। আমি এটি একাধিক উপায়ে সম্পন্ন করে দেখেছি, তবে সম্ভবত সবচেয়ে চতুর এবং ব্যবহারযোগ্য দু'এর মধ্যে Symbol[ 1 , 2 ] ক্লাসটি বানর-প্যাচিংয়ের সাথে জড়িত । আমি নীচের প্রথম উপায়টি বর্ণনা করব।

class Symbol
  def with(*args, &block)
    ->(caller, *rest) { caller.send(self, *rest, *args, &block) }
  end
end

এখন আপনি এই জাতীয় জিনিসগুলি করতে পারেন:

nums.map(&:**.with(1i))
text.map(&:gsub.with('s', '*'))
nums.take_while(&:<.with(3))
text.delete_if(&:[].with('is'))

3

জাভাস্ক্রিপ্ট পূর্বাভাস

var arr = ["Seattle", "WA", "New York", "NY", "Chicago", "IL"];

function foreach(fn, arr) {
  var s = fn.toString();
  var args = s.substring(s.indexOf('(')+1,s.indexOf(')')).split(",");
  var argsLen = args.length;
  var len = arr.length;
  for (var i = 0; i < len; i+=argsLen) {
    var part = arr.slice(i, i+argsLen);
    fn.apply(undefined, part);
  }
}

foreach (function(city, state) {
  console.log(city + ', ' + state);
}, arr);

আউটপুট

Seattle, WA
New York, NY
Chicago, IL

বিকল্প সিনট্যাক্স, আরও টিসিএল এর মতো।

// Tcl's foreach loop for javascript.
// Keys in loop are prefixed with "this".
function tclForeach(keys, values, fn) {
  var obj={}, klen=keys.length, vlen=values.length, j, i;
  for (i=0, klen=keys.length; i < klen; i++) obj[keys[i]]=null;
  for(i = 0; i < vlen; i+=klen) {
    for(j=klen; j--;) obj[keys[j]] = values[i+j];
    fn.apply(obj);
  }
}

tclForeach(["city","state"], arr, function() {
  console.log(this.city + ', ' + this.state);
});

এটি কোনও সরল ভবিষ্যদ্বাণী নয়, তবে এটি আরও আকর্ষণীয়। এটি গ্রাসকারী ফাংশনের যুক্তির তালিকাটি পরীক্ষা করে। আপনি এই কৌশলটি নিয়ে আরও এগিয়ে যেতে পারেন এবং সত্যিই দুর্দান্ত জিনিসগুলি করতে পারেন।
জোয় অ্যাডামস

1
আমি একটি টিসিএল স্টাইলের পূর্বাভাসের জন্য যাচ্ছিলাম। আমি কিছুটা ভিন্ন পদ্ধতির যোগ করেছি যা টিসিএল এর মতোই।
ওল্ফহ্যামার

2

হাস্কেল গোটোস

প্রাথমিক ধারণাটি হ'ল গোটোস নোটেশনে সর্বশেষ বিবৃতিটি ব্যবহার করে আংশিকভাবে অনুকরণ করা যায় do। উদাহরণ স্বরূপ:

main = do
  loop:
  print 3
  goto loop

সমতুল্য

main = do
  loop
loop = do
  print 3
  loop

যেহেতু মৃত্যুদন্ড কার্যকর হবে সর্বশেষ বিবৃতিতে, এটি গোটোস প্রকাশ করা সর্বোত্তম।

কারণ এটি যেভাবে করা হয়, গোটস কেবল তখনই লাফ দেয় যখন তারা doসরাসরি টপলেভেলের সংজ্ঞাতে আসে। এটি আসলে "এক্স এক্স করুন এবং বাকী সমস্ত বর্ণিত বিবৃতিগুলি উপেক্ষা করুন" পরিবর্তে "সমস্ত এক্স এবং বাকী বাক্যগুলিকে উপেক্ষা করুন", একটি বাস্তব গোটোর মতো।

সবচেয়ে বড় সমস্যাটি হ'ল যখন কোনও আইও অ্যাকশনের মাঝামাঝি থেকে ফাঁসি ছাড়ার কোনও উপায় returnনেই - এমনকি হয় না; returnএটি শেষ বিবৃতি না হলে কিছুই করে না।

এটি অন্য একটি doব্লক দ্বারা বাকী বাক্যগুলি ক্যাপচার করে এটিকে কাটিয়ে ওঠে ।

goto loop
print 3

হয়ে

const loop $ do
print 3

print 3বিবৃতি দ্বারা বন্দী করা হয় doব্লক, তাই loopশেষ কথাটা হয়ে যায়।

এই রূপান্তরটি কর্মের সুযোগে উপস্থিত ভেরিয়েবলকে সমর্থন করে। এটি স্কোপগুলিতে থাকা ভেরিয়েবলগুলি স্মরণ করে এবং ক্রিয়ায় সরিয়ে দেওয়ার মাধ্যমে এটি করা হয়। উদাহরণ স্বরূপ:

printer r = do
  loop:
  putStrLn r
  goto loop
  print "this isn't executed"

এটি কেবল অনুবাদ করে:

printer r = do
  loop r
loop = do
  putStrLn r
  const (loop r) $ do
  print "this isn't executed"

কিছু নোট:

এছাড়াও, return undefinedক্যাপচারিং doব্লকটি খালি নেই তা নিশ্চিত করার জন্য একটি বিবৃতি যুক্ত করা হয়েছে ।

কারণ কখনও কখনও ক্যাপচারিং doব্লকে ধরণের অস্পষ্টতা দেখা যায় , পরিবর্তে constআমরা ব্যবহার করি asTypeOfযা একই রকম constতবে এর উভয় পরামিতিগুলির একই ধরণের প্রয়োজন।

আসল বাস্তবায়ন (জাভাস্ক্রিপ্টে):

function makeGoto(code)
{
    var vars = [] // the known variables

    // add the arguments to the functions to scope
    code.split('\n')[0].split('=')[0].split(' ').slice(1).forEach(function(varname){vars.push(varname)})
    return code.replace(/([ \t]*)([a-zA-Z]+):|([ \t]*)goto[ \t]+([a-zA-Z]+)|[ \t]+([a-zA-Z]+)[ \t]*<-/gm, function match(match, labelSpaces, label, gotoSpaces, goto, x)
        {
            if (label != undefined)
                return labelSpaces+label+" "+vars.join(' ')+"\n"+label+" "+vars.join(' ')+"=do ";
            else if(goto != undefined)
                return gotoSpaces+"asTypeOf("+goto+" "+vars.join(' ')+")$do\n"+gotoSpaces+"return undefined";
            else
            {
                vars.push(x);
                return match
            }
        })
}

একটি উদাহরণ:

main = do
    putSrtLn "a"
    goto label
    putStrLn "b"
    label:
    putStrLn "c"

হয়ে:

main = do
    putStrLn "a"
    asTypeOf(label )$do
    return undefined
    putStrLn "b"
    label 
label =do 
    putStrLn "c"

আউটপুট:

a
c

এটি স্পষ্ট করে বলার অপেক্ষা রাখে না যে হাসকেলে returnএকটি নিয়মিত ফাংশন, এবং সি / ইত্যাদির কীওয়ার্ডের সাথে সম্পর্কিত নয়।
ফায়ারফ্লাই

1

পাইথন গোটো

goto.py

import sys, re
globals_ = globals()
def setglobals(g):
    global globals_
    globals_ = g
def goto(l):
    global globals_ 
    with open(sys.argv[0], "rb") as f:    
        data = f.read()
        data_ = data.split('\n')
    if isinstance(l, int):
        l-=1 if l > 0 else 0
    elif isinstance(l, str):
        r=re.search(r"^\s*(#{0}|(def|class)\s+{0})".format(l), data, re.MULTILINE)
        l=len(data_)-(data[r.start():].count("\n")) if r else len(data_)
    if 0 < l < len(data_) or 0 < (l*-1) <= len(data_):
        exec("".join(data_[l:]),globals_)
        sys.exit(1)

ব্যবহার

setglobals(globals()) #Set the globals to be used in exec to this file's globals (if imports or other variables are needed)
goto(8) #Goto line 8
goto(-8)#Goto 8th last line
goto("label")#Goto first occurrence of #label
goto("funcName")#Goto definition of funcName
goto("className")#Goto definition of className

নমুনা পরীক্ষার কেস

import goto, sys
goto.goto(-1)
sys.exit(-1)

print "Asdf"

নমুনা পরীক্ষার কেস আউটপুট

Asdf

এক্সিকিউট () এর সাথে একটু মজা করুন। যদি সঠিকভাবে ব্যবহার না করা হয় তবে সর্বাধিক পুনরাবৃত্তির গভীরতার ত্রুটি বাড়িয়ে তুলতে পারে।


-2

// কোনও HTML পৃষ্ঠায় স্ক্রিপ্ট ট্যাগটি স্পষ্টভাবে ব্যবহার না করে জাভাস্ক্রিপ্ট আমদানি করুন

function i(u) {
  document.write("script src=\" + u + \"></script>");
}

i("http://www.mysite.com/myscript.js");

এটা খোঁড়া হাঁ আমি জানি। দৈর্ঘ্য: 99


@ user2509848: এই থ্রেড কোড গল্ফ ট্যাগ করা হয় না।
জোয় অ্যাডামস

আপনি যা পোস্ট করেছেন তার scriptচারপাশে ট্যাগ লাগবে। তাহলে নতুন বৈশিষ্ট্যটি ঠিক কোথায়?
manatwork

@ জোএএডামস ওফস, দুঃখিত
হোচচ 5050
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.