मैं एक Slice को गतिशील रूप से परिभाषित करना चाहता हूं, जो या तो आगे या पीछे के सूचकांक पर आधारित हो सकता है (इस पर निर्भर करता है कि इसकी प्रारंभिक स्थिति सकारात्मक या नकारात्मक संख्या के रूप में दी गई है)।

मैं https://play.nim-lang.org/ पर चीज़ें आज़मा रहा हूं

मैंने एक संघ प्रकार की कोशिश की:

type mySlice = Slice[BackwardsIndex] | Slice[int]
var sl: mySlice
let s = "1234567890"
let bcStart = 3
let bcLen = 3
if bcLen < 0:
  sl = (bcStart-1)..<(bcStart+bcLen-1)
else:
  sl = ^(bcStart+bcLen-1)..^(bcStart)
echo s[sl]

यह /usercode/in.nim(2, 5) Error: invalid type: 'mySlice' for var के साथ विफल हो जाता है।

मैंने कोशिश की

let s = "1234567890"
let bcStart = 3
let bcLen = 3
if bcLen < 0:
  let sl = (bcStart-1)..<(bcStart+bcLen-1)
else:
  let sl = ^(bcStart+bcLen-1)..^(bcStart)
echo s[sl]

और यह इस प्रकार विफल रहता है:

/usercode/in.nim(5, 7) Hint: 'sl' is declared but not used [XDeclaredButNotUsed]
/usercode/in.nim(7, 7) Hint: 'sl' is declared but not used [XDeclaredButNotUsed]
/usercode/in.nim(8, 8) Error: undeclared identifier: 'sl'

और मैंने निम्नलिखित की भी कोशिश की:

let s = "1234567890"
let bcStart = 3
let bcLen = 3
let sl =
  if bcLen < 0:
    (bcStart-1)..<(bcStart+bcLen-1)
  else:
    ^(bcStart+bcLen-1)..^(bcStart)
echo s[sl]

असफल होने का एक अलग तरीका के साथ:

/usercode/in.nim(8, 23) Error: type mismatch: got <HSlice[system.BackwardsIndex, system.BackwardsIndex]> but expected 'HSlice[system.int, system.int]'

वे विफलताएं क्यों हैं, और मुझे कैसे करना चाहिए?

संपादित करें (09/09/2020) वांछित एपीआई

मेरा उपयोग मामला उससे अधिक जटिल है, लेकिन यह एक कमांड-लाइन प्रोग्राम के बराबर है जो तर्क के रूप में एक इनपुट टेक्स्ट, एक "बारकोड" और एक बारकोड प्रारंभ स्थिति लेता है, और यह बताता है कि बारकोड इनपुट टेक्स्ट में मौजूद है या नहीं। निर्दिष्ट स्थिति। यदि स्थिति को ऋणात्मक पूर्णांक के रूप में दिया जाता है, तो इसका अर्थ है कि हम अंत से एक स्थिति निर्दिष्ट करते हैं।

मेरे पास उम्मीद के मुताबिक कुछ काम कर रहा है:

$ cat src/test.nim
import docopt
from strutils import parseInt

# https://github.com/docopt/docopt.nim
const doc = """

Usage:
  test -t <input_text> -b <barcode> -s <barcode_start>

-h --help                                 Show this help message and exit.
-t --input_text <input_text>              Text in which to search for the barcode.
-b --barcode <barcode>                    Barcode to search.
-s --barcode_start <barcode_start>        Position at which the barcode starts (1-based), negative if from end.
"""

proc match_text(inText: string, barcode: string, bcStart: int): bool =
  var
    bcSeq: string
    bcLen: int = barcode.len
  if bcStart < 0:
    bcSeq = inText[^(bcLen - bcStart - 1)..^(-bcStart)]
  else:
    bcSeq = inText[(bcStart-1)..<(bcStart + bcLen - 1)]
  if bcSeq == barcode:
    result = true
  else:
    result = false

when isMainModule:
  let args = docopt(doc)
  var
    barcode: string
    inText: string
    bcStart: int
  for opt, val in args.pairs():
    case opt
    of "-t", "--input_text":
      inText = $args[opt]
    of "-b", "--barcode":
      barcode = $args[opt]
    of "-s", "--barcode_start":
      bcStart = parseInt($val)
    else:
      echo "Unknown option" & opt
      quit(QuitFailure)
  if match_text(inText, barcode, bcStart):
    echo "Matches"
  else:
    echo "Doesn't match"

निर्माण का कार्य:

$ nimble build
# [successful build output]

परीक्षण कार्य:

$ ./bin/test -t aacgttb -b aa -s 1
Matches
$ ./bin/test -t aacgttb -b aa -s 2
Doesn't match
$ ./bin/test -t aacgttb -b tt -s -1
Doesn't match
$ ./bin/test -t aacgttb -b tt -s -2
Matches

हालांकि, मेरे वास्तविक अनुप्रयोग में, मैं पाठ के विभिन्न टुकड़ों में एक ही स्लाइसिंग का कई बार पुन: उपयोग कर रहा हूं, इसलिए मैं एक Slice ऑब्जेक्ट को परिभाषित करना चाहता हूं जिसे मैं बार-बार कंप्यूटिंग के बजाय पुन: उपयोग कर सकता हूं टुकड़ा "इन-प्लेस"।