小编aka*_*nom的帖子

我有类型的记录

type tradeLeg = {
    id : int ;
    tradeId : int ;
    legActivity : LegActivityType ;
    actedOn : DateTime ;
    estimates : legComponents ;
    entryType : ShareOrDollarBased ;
    confirmedPrice: DollarsPerShare option;
    actuals : legComponents option ; 


type trade = {
    id : int ;
    securityId : int ;
    ricCode : string ;
    tradeActivity : TradeType ;
    enteredOn : DateTime ;
    closedOn : DateTime ;
    tradeLegs : tradeLeg list  ;
}

贸易腿显然是一种交易类型.一条腿可能已经结算或未结算(或未结算但已确认价格) - 因此我已定义了活动模式:

let (|LegIsSettled|LegIsConfirmed|LegIsUnsettled|) (l: tradeLeg) = 
        if …

我在F#中有一个自定义类,我想实现[] list运算符

let myClass = new myClassObj()
let someVal  = myClass.[2]

我似乎无法在网上找到这个 - 我可能不知道正确的术语来搜索...提前感谢

基本上我想有一个单一的构造来处理序列化到 JSON 和格式化的 xml。Records 可以很好地序列化到 json 或从 json 序列化。但是 XmlSerializer 需要一个无参数的构造函数。我真的不想经历为这些构造构建类对象的练习（仅限原则）。我希望可以有一些快捷方式将无参数构造函数放到记录上（也许使用 wioth 语句或其他东西）。我无法让它表现 - 社区中有人有运气吗？

module JSONExample
    open System
    open System.IO 
    open System.Net 
    open System.Text 
    open System.Web 
    open System.Xml
    open System.Security.Authentication 
    open System.Runtime.Serialization //add assemnbly reference System.Runtime.Serialization System.Xml
    open System.Xml.Serialization
    open System.Collections.Generic 

    [<DataContract>]            
    type ChemicalElementRecord = { 
        [<XmlAttribute("name")>]
        [<field: DataMember(Name="name") >] 
        Name:string 

        [<XmlAttribute("name")>]
        [<field: DataMember(Name="boiling_point") >] 
        BoilingPoint:string 

        [<XmlAttribute("atomic-mass")>]
        [<field: DataMember(Name="atomic_mass") >] 
        AtomicMass:string 
    } 

    [<XmlRoot("freebase")>]
    [<DataContract>] 
    type FreebaseResultRecord = { 
        [<XmlAttribute("code")>]
        [<field: DataMember(Name="code") >] 
        Code:string 

        [<XmlArrayAttribute("results")>]
        [<XmlArrayItem(typeof<ChemicalElementRecord>, ElementName = "chemical-element")>]
        [<field: …

我永远找不到 F# 核心库的源代码。我知道它应该是开放的，但谷歌在帮助我找到它时对我并不友好，如果是这样，我会查找 Seq.fold 的实现 - 但问题就在这里。

有没有人看到以下代码段有任何问题：

let success = myList |>
                    Seq.fold 
                        (fun acc item -> evaluation item)
                        false 

从逻辑上讲，它似乎不保水，我可以并且将尝试对其进行测试。但我想问社区。如果 myList 中的任何单个评估返回 false，我希望成功变量为 false...

所以测试：

let myList = [true; true]
let success = List.fold (fun acc item -> acc && item) true myList

和

let myList = [true; false; true]
let success = List.fold (fun acc item -> acc && item) true myList

确实返回正确的结果 - 我只是看到源会更舒服......

由于某些原因,我序列化一个类型(f#):

type JsonKeyValuePair<'T, 'S> =  {
    [<DataMember>] 
    mutable key : 'T
    [<DataMember>] 
    mutable value : 'S
}

let printJson() = 

    use stream = new MemoryStream() 
    use reader = new System.IO.StreamReader(stream)

    let o = {key = "a"; value = 1 }
    let jsonSerializer = Json.DataContractJsonSerializer(typeof<TestGrounds.JsonKeyValuePair<string, int>>)

    jsonSerializer.WriteObject (stream , o)
    stream.Seek(int64 0, SeekOrigin.Begin) |> ignore 

    printfn <| Printf.TextWriterFormat<unit>(reader.ReadToEnd())
    ()

它生成一个字符串:

{ "键@": "一", "值@":1}

如果我尝试在没有@符号的情况下反序列化它:

let deserialize() = 
    let json = "{\"key\":\"b\",\"value\":2}"
    let o  = deserializeString<TestGrounds.JsonKeyValuePair<string, int>> json
    ()

{"数据协定类型'TestGrounds.JsonKeyValuePair`2 [[System.String,mscorlib,Version …

我正在使用django rest框架来输出文章的内容.它工作得很精彩,除了现在我想修改行为不返回完整的"内容",而是一个预告片(比如内容的前200个字符,但理想情况下我希望能够添加任何逻辑,比如说200个字符后的第一句结尾):

class ArticleSerializer(serializers.HyperlinkedModelSerializer):
    user = UserSerializer(many=False, read_only=True)

    class Meta:
        model = models.Article
        fields = (
            'id'
            ,'title'
            , 'date_added'
            , 'content'
            , 'user'
        )

我看了GenericAPIView,我认为可能有一些东西要覆盖 - 但没有什么看起来很明显 - 有人可以提供一些见解吗？先感谢您

我在一个共同的地方定义了这个：

[<DataContract>]
type ResultObject = {
    [<DataMember>]
    mutable field1: string
    [<DataMember>]
    mutable field2: string
    [<DataMember>]
    mutable field3: int 
}

let createCache<'T> () =
    Dictionary<_, 'T option>(HashIdentity.Structural)  


let memoizeSingleParamWithCallback<'R, 'P when 'P : equality>  functionToMemoize =    

    let cache = createCache<'R>() 

    // return a function that takes two parameters a parameter to the functionToMemoize  and a callback 
    fun (parameter: 'P) (callback: Action<_>) ->
        // form a unique cache key the parameterValue
        let key = parameter

        // check to see if the cache …

我们有一个基于生产网络的产品,允许用户对商品的未来价值(或需求)做出预测,历史数据包含大约10万个例子,每个例子有大约5个参数;

考虑一类称为谓词的数据:

prediction {
    id: int
    predictor: int    
    predictionDate: date
    predictedProductId: int
    predictedDirection: byte  (0 for decrease, 1 for increase)
    valueAtPrediciton: float
}

以及测量预测结果的配对结果类:

predictionResult {
    id: int
    valueTenDaysAfterPrediction: float
    valueTwentyDaysAfterPrediction: float
    valueThirtyDaysAfterPrediction: float
}

我们可以定义一个成功的测试用例,其中如果任何两个未来的值检查点在预测时考虑方向和值时是有利的.

success(p: prediction, r: predictionResult): bool = 
    count: int 
    count = 0

    // value is predicted to fall
    if p.predictedDirection = 0 then
       if p.valueAtPrediciton > r.valueTenDaysAfterPrediction then count = count + 1
       if p.valueAtPrediciton > r.valueTwentyDaysAfterPrediction then count = count + 1
       if p.valueAtPrediciton …

    let csvList startDelim endDelim lst memF = 
        let listIter (listStr: string) item = 
            if listStr.Length > 0 then 
                listStr + "," + (memF item)
            else 
                memF item                
        startDelim + (List.fold listIter "" lst) + endDelim

    let listIntoJsonArray = csvList "[" "]"
    let listIntoJsonObject = csvList "{" "}"

    let intConverter (item:int) : string =
        item.ToString()

    let objectConverter (item:SomeObject) : string =
        item.value.ToString()

    let objects = [{vaue: 12.3}; {vaule: 33.2}]
    let ints = [1;2;4]

    let o = listIntoJsonObject objects objectConverter
    let i …

我正在处理一个示例 Ruby/Grape 示例，除了 json 被转义外，一切正常。我也是全新的 ruby​​ 及其框架（仅 3 天），如果这个问题是补救性的，那么很抱歉，并提前感谢您

我相当肯定不应该对引号进行转义，无论如何这里是转义的输出：

"{\"word\":\"test\",\"sentiment\":\"unkown\"}"

我的代码

require 'rubygems'
require 'grape'
require 'json'

class SentimentApiV1  < Grape::API
  version 'v1', :using => :path, :vendor => '3scale'
  format :json

  resource :words do
    get ':word' do
        {:word => params[:word], :sentiment => "unkown"}.to_json
    end

    post ':word' do
      {:word => params[:word], :result => "thinking"}.to_json
    end 
  end

  resource :sentences do
    get ':sentence' do
      {:sentence => params[:sentence], :result => "unkown"}.to_json
    end
  end

end

配置文件

$:.unshift "./app"

需要'sentimentapi_v1.rb'

运行 SentimentApiV1

包和版本

C:\Ruby-Projects\GrapeTest>bundle install …

有没有更好的方法可以迭代生成器的结果，我的for循环很丑陋：

for(let job = readyJob.next(); !job.done; job = readyJob.next()){ } 

在上下文中，有一个生成器函数可以确定是否存在由1 .. *个作业组成的一批工作（生成器也可能在批处理中不返回任何作业）。有一个连续的循环实例化生成器并遍历批处理工作（记录）。

有没有更好的解决此迭代问题的方法。我的意思是，这看起来像Java / C＃的传统迭代器，还不错。像“每个”这样的东西是超级可读的……无论如何，这就是我的希望。

 let getReadyJob = function *(instance){
    let numJobs = 7 ; // getRandomInt(0, 10) ;
    for(let i = 0; i < numJobs; i++) {
        yield {
            jobId: '' + instance + '::' + i,
            jobReadyOn: (new Date()).valueOf()
        };
    }
}

然后

while(true){
    let readyJob = getReadyJob()

    for(let job = readyJob.next(); !job.done; job = readyJob.next()){
        console.log(JSON.stringify(job.value)) ;
    }
}

我正在尝试创建一个类,它将存储一组时间序列的数据 - 按组进行组织,但我有一些编译错误,所以我剥离了基础知识(只是一个简单的实例化),仍然无法克服编译错误.我希望有人可能以前见过这个问题.Clas定义为:

type TimeSeriesQueue<'V, 'K when 'K: comparison> = class
        val private m_daysInCache: int  
        val private m_cache: Map<'K, 'V list ref > ref;
        val private m_getKey: ('V -> 'K) ;

        private new(getKey)  = {
            m_cache = ref Map.empty
            m_daysInCache  = 7 ;
            m_getKey = getKey ;
        }

end

所以对我来说看起来没问题(它可能不是,但没有任何错误或警告) - 实例化得到错误:

type tempRec = {
    someKey: string ;
    someVal1: int ;
    someVal2: int ;
}

let keyFunc r:tempRec = r.someKey
// error occurs on the following line
let q …